• Author / Uploaded
• Edwin Chaparro

Citation preview

1Actividad de Aprendizaje No. 6

Nombres: Chaparro Arboleda Edwin Javier

Universidad Unipanamericana Bogotá D.C 2020

1Actividad de Aprendizaje No. 6

Nombres: Chaparro Arboleda Edwin Javier

Docentes: Camilo Alfonso Salamanca

Universidad Unipanamericana Bogotá D.C 2020

ii

Tabla de Contenidos

iii

Introducción.....................................................................................................................................1 Objetivo General..............................................................................................................................2 CAPITULO 1...................................................................................................................................3 Práctica 1.....................................................................................................................................3 Práctica 2 Ficheros.......................................................................................................................5 Práctica 3- Threads......................................................................................................................8 Práctica 4 – threads II................................................................................................................10 Práctica 5 - Señales....................................................................................................................14 Práctica 6 - Planificación...........................................................................................................15 Práctica 7- Planificación - II......................................................................................................17 Práctica 8 - Shell........................................................................................................................18

iv

Tabla de Ilustraciones Ilustración 1.....................................................................................................................................4 Ilustración 2.....................................................................................................................................5 Ilustración 3.....................................................................................................................................7 Ilustración 4.....................................................................................................................................8 Ilustración 5.....................................................................................................................................8 Ilustración 6...................................................................................................................................13 Ilustración 7...................................................................................................................................18 Ilustración 8...................................................................................................................................19 Ilustración 9...................................................................................................................................19 Ilustración 10.................................................................................................................................20 Ilustración 11.................................................................................................................................20 Ilustración 12.................................................................................................................................21 Ilustración 13.................................................................................................................................21 Ilustración 14.................................................................................................................................22

Introducción

Evidenciar el concepto, manejo, configuración de los sistemas operativos involucrado la temática de remoto, comunicaciones, servidores web

Objetivo General Aplicar los temas de remoto, comunicaciones de servidores web con el uso de sistemas operativos.

CAPITULO 1 ACTIVIDAD Condiciones básicas para el desarrollo de la actividad: 1. Lectura y apropiación de los temas de Sistemas operativos 1. Majeo de Internet 1. Desarrollo de la actividad asignado durante toda la asignatura. 1. Se recomienda realizar primera la contextualización y apropiación de conceptos para proseguir en la elaboración de modelos entidad relación. 1. Es de gran importancia el aprendizaje autónomo, la lectura y práctica de los ejercicios en esta materia. ACTIVIDAD Práctica 1 Gestión de procesos y threads Desarrollar un programa que cree varios procesos concurrentes, que escriban periódicamente mensajes diferentes en la pantalla Hacer lo mismo con threads periódicos. Pasar a cada thread como parámetros el periodo y el mensaje a escribir. Los threads se crearán en estado "independiente" Para ello se utiliza el siguiente código. //para lanzar hilos se hacen desde objetos //que heredan de thread //con star se lanzan los hilos package javaapplication76; import java.util.Timer; import java.util.TimerTask; import java.util.logging.Level; import java.util.logging.Logger; public class principal extends Thread{ private int id; public principal (int id){ this.id = id; }

public void run() { System.out.println("Mensaje generado por el hilo Numero: "+id); } public static void main(String[] args) throws InterruptedException { principal h1 = new principal(1); principal h2 = new principal(2); principal h3 = new principal(3); Thread.sleep(2000); h1.start(); Thread.sleep(2000); h2.start(); Thread.sleep(2000); h3.start(); Thread.sleep(2000); System.out.println("Mensaje generado por el hilo principal"); } }

Ilustración 1

Ilustración 2 El periodo es de 3 segundos por hilo. Práctica 2 Ficheros Escribir un programa que copie los contenidos de un fichero en otro. Se pasarán los nombres como argumentos al programa. Modificarlo para que ponga el estado del fichero generado según los parámetros de entrada que se le pasen los permisos del usuario (rwx) Asimismo, deberá presentar información del estado de los ficheros (original y copia) en pantalla (fechas, tamaño, etc.) En el desarrollo de este ejercicio se utilizó el siguiente script import java.io.*; public class CopiarFicherosYCarpetas { public static int EntraIncial=0; public static void main(String[] args) { //ruta de la carpeta que vamos a copiar File FOrigen=new File("T:\\portatil\\universidad\\quinto semestre"); //ruta de donde vamos a copiar la carpeta File FDestino=new File("C:\\Users\\Javier Contreras\\Desktop\\"); Copiar(FOrigen,FDestino); EntraIncial=0; } public static void Copiar(File FOrigen,File FDestino){ //verificamos si el origen es una carpeta

if(!FOrigen.isDirectory()){ CopiarFichero(FOrigen,FDestino); }else{ EntraIncial++; if(EntraIncial==1){ FDestino=new File(FDestino.getAbsolutePath()+"/"+FOrigen.getName()); if(!FDestino.exists()){ FDestino.mkdir(); } } String []Rutas=FOrigen.list(); for(int i=0;i 0) { Salida.write(buffer, 0, tamaño); } System.out.println(FOrigen.getName()+" Copiado con Exito!!"); Salida.close(); LeeOrigen.close(); }

}else{ System.out.println("El fichero a copiar no existe..."+FOrigen.getAbsolutePath()); } } catch (Exception ex) { System.out.println(ex.getMessage()); } } }

Ilustración 3 Esta es la carpeta de destino, donde se evidencia que no está la carpeta

Aquí vemos la ruta de origen y destino de la carpeta que va a ser copiada y procedemos a ejecutar el programa.

Ilustración 4 Aquí vemos que ya fue copiada.

Ilustración 5

Práctica 3- Threads Escribir un programa con tres threads que se sincronicen para acceder de manera mutuamente exclusiva a un conjunto de datos que representan las coordenadas x,y,z de un cuerpo en el espacio Uno de los threads deberá modificar los datos de manera periódica según las siguientes ecuaciones (una recta):

x = x + 0, 1 y = 3x + 8 z = 4x – 2y + 3 Otro thread consulta esa información y muestra x,y,z y también (y-3x), que debe ser 8 Otro thread consulta esa información y muestra x ,y,z y también (z-4x+2y), que debe ser 3 Para la protección de los datos se usará un mutex. El programa se ejecutará con y sin protección, y así podrá observarse la inconsistencia del conjunto de datos cuando no hay protección Puede utilizarse el "come tiempos" que se encuentra en los ficheros load.c y load.h disponibles en el servidor. Cópialos en tu directorio de trabajo. // creamos estructura para pase de parámetros struct pthread_st { double X1; double X2; double X3; }; ... ... int main () { // definimos una variable de tipo estructura creada pthread_st pthread_data; ... // asignamos valores a los parámetros antes de crear la hebra pthread_data.X1:=1; pthread_data.X2:=2; pthread_data.X3:=3; // pasamos como parámetro la dirección de la variable de tipo estructura // redefinida como puntero void. pthread_create( &pthread_id, &attr, controller, (void *) &pthread_data); ... ... ... } // recogida de parámetros en la rutina de inicio void * controller (void *parms) { double X; double Y; double Z; // definimos una variable tipo puntero a estructura pthread_st *pthread_dt; // asignamos el valor del puntero pasado como parámetro “parms”, el cual

// ‘apunta’ a la variable pthread_data definida en main(), a la // variable local pthread_dt. thread_data=(pthread_st *) parms; // redefinimos el tipo de “parms” // asignamos los valores pasados a varibales internas // en X,Y,Z tendremos los valores 1, 2, 3. X=thread_data->X1; Y=thread_data->X2; Z=thread_data->X3; ... ... ... } Práctica 4 – threads II Escribir un programa con un thread productor de datos y un thread consumidor de estos datos. Los datos serán strings. Tanto el productor como el consumidor tendrán tiempos de ejecución aleatorios dentro de un rango (usar load.h) Utilizarán una variable compartida para la comunicación contiene un string y un booleano que dice si hay un dato válido o no Utilizarán un mutex para acceder a la variable Utilizarán dos variables condicionales. Una para que el productor espere cuando la variable compartida está ocupada Otra para que el consumidor espere cuando la variable compartida está vacía. Una vez realizado el programa, jugar con él variando los rangos de los tiempos; practicar con un productor muy rápido o muy lento, consumidores iguales, o uno más lento, o más rápido, etc. Para la solución de este ejercicio se utilizó el siguiente código. //CODIGO EXTRAIDO DE http://dis.um.es/~bmoros/Tutorial/parte10/cap10-6.html class Productor extends Thread { private Tuberia tuberia; private String alfabeto = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; public Productor( Tuberia t ) { // Mantiene una copia propia del objeto compartido tuberia = t; } public void run() { char c;

// Mete 10 letras en la tubería for( int i=0; i < 10; i++ ) { c = alfabeto.charAt( (int)(Math.random()*26 ) ); tuberia.lanzar( c ); // Imprime un registro con lo añadido System.out.println( "LETRA ASIGNADA "+c+" " ); // Espera un poco antes de añadir más letras try { sleep( (int)(Math.random() * 100 ) ); } catch( InterruptedException e ) { ; } } } } class Consumidor extends Thread { private Tuberia tuberia; public Consumidor( Tuberia t ) { // Mantiene una copia propia del objeto compartido tuberia = t; } public void run() { char c; // Consume 10 letras de la tubería for( int i=0; i < 10; i++ ) { c = tuberia.recoger(); // Imprime las letras retiradas System.out.println( "LETRA ELIMINADA "+c ); // Espera un poco antes de coger más letras try { sleep( (int)(Math.random() * 2000 ) ); } catch( InterruptedException e ) { ; } } }

} class Tuberia { private char buffer[] = new char[6]; private int siguiente = 0; // Flags para saber el estado del buffer private boolean estaLlena = false; private boolean estaVacia = true; // Método para retirar letras del buffer public synchronized char recoger() { // No se puede consumir si el buffer está vacío while( estaVacia == true ) { try { wait(); // Se sale cuando estaVacia cambia a false } catch( InterruptedException e ) { ; } } // Decrementa la cuenta, ya que va a consumir una letra siguiente--; // Comprueba si se retiró la última letra if( siguiente == 0 ) estaVacia = true; // El buffer no puede estar lleno, porque acabamos de consumir estaLlena = false; notify(); // Devuelve la letra al thread consumidor return( buffer[siguiente] ); } // Método para añadir letras al buffer public synchronized void lanzar( char c ) { // Espera hasta que haya sitio para otra letra while( estaLlena == true ) { try { wait(); // Se sale cuando estaLlena cambia a false } catch( InterruptedException e ) { ; } }

// Añade una letra en el primer lugar disponible buffer[siguiente] = c; // Cambia al siguiente lugar disponible siguiente++; // Comprueba si el buffer está lleno if( siguiente == 6 ) estaLlena = true; estaVacia = false; notify(); } } class ejercicio4 { public static void main( String args[] ) { Tuberia t = new Tuberia(); Productor p = new Productor( t ); Consumidor c = new Consumidor( t ); p.start(); c.start(); } }

Ilustración 6 Práctica 5 - Señales Probar el programa enviándole señales desde una shell (con la orden kill -num_señal pid) Nota: Según la versión de Linux se pueden crear (incorrectamente) varios procesos si hay manejadores de señal. #include #include #include #include #include // Aquí se declaran las variables globales // y los prototipos de las funciones int main(); int main() { int cuenta=0; DIR * dir; char directorio[255]; struct dirent* entrada; if (getcwd(directorio, 255)== NULL) {

perror("Error obteniendo dir. actual: "); return -1; } dir = opendir(directorio); if (dir == NULL) { perror("Error abriendo directorio: "); return -1; } entrada = readdir(dir); while(entrada != NULL) { cuenta++; //free(entrada); entrada = readdir(dir); } printf("Entradas: %i\n", cuenta); if (closedir(dir) == -1) { perror("Error cerrando directorio: "); return -1; } return 0; } Práctica 6 - Planificación Escribir un programa que cree dos threads periódicos concurrentes. A cada thread se le pasará como parámetro: periodo tiempo de ejecución número de identificación Para hacer threads periódicos se usará la función clock_nanosleep() inicialmente se pueden hacer pseudo-periódicos con sleep() Para simular el tiempo de ejecución se usa la función eat() suministrada Cada décima de segundo de tiempo de ejecución consumido se pondrá un mensaje en la pantalla con el identificador del thread También se pondrán mensajes al inicio y final del periodo A partir de la secuencia de ejecución dibujar un diagrama temporal de la ejecución Tratar de inferir a partir del diagrama el tipo de planificación (expulsora o no; cíclica, FIFO, ...); probar con dos combinaciones diferentes de periodos y tiempos de ejecución Compilar y ejecutar el programa desarrollado para Linux en el sistema operativo MaRTE OS sobre máquina desnuda: Hacer las mismas pruebas que en el caso anterior Para ello: Ajustar la variable PATH ejecutando . /usr/local/marte-1.9/martevars.sh ompilar el programa con mgcc

Copiar el programa en el servidor cp el_programa /net/lctrserver/mprogram_HOSTNAME Encender el computador (PC industrial) class TareaCompleja implements Runnable{ @Override public void run() { for (int i=0; i