MECANISMOS DE SINCRONIZACIÓN PROGRAMACIÓN CONCURRENTE Y PARALELA

Transcripción

1 MECANISMOS DE SINCRONIZACIÓN PROGRAMACIÓN CONCURRENTE Y PARALELA

2 Sincronización El problema de la sincronización de hilos tiene lugar cuando varios hilos intentan acceder al mismo recurso o dato. A la hora de acceder a datos comunes, los hilos necesitan establecer cierto orden. La inanición tiene lugar cuando uno o más hilos están bloqueados al intentar conseguir acceso a un recurso compartido de ocurrencias limitadas El interbloqueo es la última fase de la inanición; ocurre cuando uno o más hilos están esperando una condición que no puede ser satisfecha.

3 Memoria Compartida Si los diferentes procesos de un programa concurrente tienen acceso a variables globales o secciones de memoria comunes, la transferencia de datos a través de ella es una vía habitual de comunicación y sincronización entre ellos.

4 Ejemplo Realizar el incremento de N hasta 20, siendo la variable compartida entre dos hilos, de forma sincronizada

5 Clase Recurso Compartido import java.io.*; public class Recurso_Compartido private int contador; synchronized Asegura que solo entre un solo hilo a la sección critica, pero no implica que entre en forma alternada ni ordenada La salida aun puede variar es decir: public Recurso_Compartido() contador=0; public synchronized void aumentar() contador=contador+1; System.out.println ("numero es"+contador); Numero=1 Hilo 1 Numero=2 Hilo 1 Numero=3 Hilo 1 Numero=1 Hilo 2

6 class Proceso1 extends Thread private Recurso_Compartido contar; public Proceso1(Recurso_Compartido contar) this.contar=contar; public void run() for(int i=1; i<=10; i++) contar.aumentar(); class Proceso2 extends Thread private Recurso_Compartido contar; public Proceso2(Recurso_Compartido contar) this.contar=contar; public void run() for(int i=1; i<=10; i++) contar.aumentar();

7 public class SumaHilos public static void main (String args[]) Recurso_Compartido contador= new Recurso_Compartido(); Proceso1 contador1= new Proceso1(contador); Proceso2 contador2= new Proceso2(contador); contador1.start(); contador2.start(); Configuration: <Default> numero es =1 numero es =2 numero es =3 numero es =4 numero es =5 numero es =6 numero es =7 numero es =8 numero es =9 numero es =10 numero es =11 numero es =12 numero es =13 numero es =14 numero es =15 numero es =16 numero es =17 numero es =18 numero es =19 numero es =20 Process completed.

8 Formas de Interactuar Procesos Los procesos que ejecutan de forma Concurrente en un sistema se pueden clasificar como procesos independientes o cooperantes. Un proceso independiente es aquel que Ejecuta sin requerir la ayuda o cooperación de otros procesos. Los procesos son cooperantes cuando están diseñados para trabajar conjuntamente en alguna actividad, para lo que deben ser capaces de comunicarse e interactuar entre ellos.

9 Sincronización y Comunicación Métodos Sincronizados public tipo synchronized nombre_metodo () Sincronización public synchronized void aumentar() while (entrada == false) Comunicación try Cambia a estado de espera wait(); catch (InterruptedException e) entrada= false; Comunica que ya esta libre la sección critica notify ();

10 Comunicación por tareas import java.io.*; public class Recurso_Compartido private int contador; private boolean entrada=true; public Recurso_Compartido() contador=0; public synchronized void aumentar(string Nombre) while (entrada == false) try wait(); catch (InterruptedException e) contador=contador+1; System.out.println ( "Nombre: "+ Thread.currentThread().getName() + Nombre + "numero es =" + contador ); entrada= true; notify (); //fin del método sincronizado // fin de clase

11 class Hilo1 extends Thread private Recurso_Compartido contar; private String Nombre; public Proceso1(Recurso_Compartido contar, String Nombre1) this.contar=contar; This.Nombre=Nombre1; public void run() for(int i=1; i<=10; i++) contar.aumentar(nombre); class Hilo2 extends Thread private Recurso_Compartido contar; private String Nombre; public Proceso1(Recurso_Compartido contar, String Nombre1) this.contar=contar; public void run() for(int i=1; i<=10; i++) contar.aumentar(nombre);

12 public class SumaHilos public static void main (String args[]) Recurso_Compartido contador= new Recurso_Compartido(); Hilo1 contador1= new Hilo1(contador,"Hilo1"); Hilo2 contador2= new Hilo2(contador,"Hilo2"); contador1.start(); contador2.start(); Nombre: Thread-0 Hilo1 numero es = 1 Nombre: Thread-0 Hilo1 numero es = 2 Nombre: Thread-0 Hilo1 numero es = 3 Nombre: Thread-0 Hilo1 numero es = 4 Nombre: Thread-0 Hilo1 numero es = 5 Nombre: Thread-0 Hilo1 numero es = 6 Nombre: Thread-0 Hilo1 numero es = 7 Nombre: Thread-0 Hilo1 numero es = 8 Nombre: Thread-0 Hilo1 numero es = 9 Nombre: Thread-0 Hilo1 numero es = 10 Nombre: Thread-1 Hilo2 numero es = 11 Nombre: Thread-1 Hilo2 numero es = 12 Nombre: Thread-1 Hilo2 numero es = 13 Nombre: Thread-1 Hilo2 numero es = 14 Nombre: Thread-1 Hilo2 numero es = 15 Nombre: Thread-1 Hilo2 numero es = 16 Nombre: Thread-1 Hilo2 numero es = 17 Nombre: Thread-1 Hilo2 numero es = 18 Nombre: Thread-1 Hilo2 numero es = 19 Nombre: Thread-1 Hilo2 numero es = 20 Process completed.

13 Comunicación por turnos alternados import java.io.*; public class RecursoCompartidoComunicado private int contador; private boolean entrada=true; public RecursoCompartidoComunicado() contador=0;

14 public synchronized void aumentarhilo1(string Nombre) while (entrada == false) try wait(); catch (InterruptedException e) contador=contador+1; System.out.println ( "Nombre: "+ Thread.currentThread().getName() + " "+ Nombre + " "+ "numero es =" + contador ); entrada= false; notify (); public synchronized void aumentarhilo2(string Nombre) while (entrada == true) try wait(); catch (InterruptedException e) contador=contador+1; System.out.println ( "Nombre: "+ Thread.currentThread().getName() +" "+ Nombre + "numero es =" + contador ); entrada= true; notify (); // finde clase

15 class Hilo1 extends Thread private RecursoCompartidoComunicado contar; private String Nombre; public Hilo1(RecursoCompartidoComunicado contar, String Nombre) this.contar=contar; this.nombre=nombre; public void run() for(int i=1; i<=10; i++) contar.aumentarhilo1(nombre); class Hilo2 extends Thread private RecursoCompartidoComunicado contar; private String Nombre; public Hilo2(RecursoCompartidoComunicado contar, String Nombre) this.contar=contar; this.nombre=nombre; public void run() for(int i=1; i<=10; i++) contar.aumentarhilo2(nombre);

16 Actividad Colaborativa Realizar de forma sincronizada y comunicada de forma alternada la cooperación de dos hilos para escribir Hola Mundo 10 veces. Hilo 1 escribe Hola y Hilo 2 escribe Mundo, además especificar el nombre del hilo.

17 Tarea en Binas Realizar de forma sincronizada y comunicada de forma alternada la cooperación de dos hilos para identificar que números son pares y que números son impares de una serie de 1 a 50 y escribe la suma de cada uno. Realizar de forma sincronizada y comunicada de forma alternada la cooperación de dos hilos para identificar que números son positivos y que números son negativos de una serie de -100 a 100 y escribe la suma de cada uni Fecha de Entrega: laboratorio 17 de septiembre de 2013

18 public class SumaHilosComunicado public static void main (String args[]) RecursoCompartidoComunicado contador= new RecursoCompartidoComunicado(); Hilo1 contador1= new Hilo1(contador,"Hilo1"); Hilo2 contador2= new Hilo2(contador,"Hilo2"); contador1.start(); contador2.start(); Configuration: <Default> Nombre: Thread-0 Hilo1 numero es =1 Nombre: Thread-1 Hilo2 numero es =2 Nombre: Thread-0 Hilo1 numero es =3 Nombre: Thread-1 Hilo2 numero es =4 Nombre: Thread-0 Hilo1 numero es =5 Nombre: Thread-1 Hilo2 numero es =6 Nombre: Thread-0 Hilo1 numero es =7 Nombre: Thread-1 Hilo2 numero es =8 Nombre: Thread-0 Hilo1 numero es =9 Nombre: Thread-1 Hilo2 numero es =10 Nombre: Thread-0 Hilo1 numero es =11 Nombre: Thread-1 Hilo2 numero es =12 Nombre: Thread-0 Hilo1 numero es =13 Nombre: Thread-1 Hilo2 numero es =14 Nombre: Thread-0 Hilo1 numero es =15 Nombre: Thread-1 Hilo2 numero es =16 Nombre: Thread-0 Hilo1 numero es =17 Nombre: Thread-1 Hilo2 numero es =18 Nombre: Thread-0 Hilo1 numero es =19 Nombre: Thread-1 Hilo2 numero es =20 Process completed.

19 Mecanismos de Comunicación en Programación Concurrente Los mecanismos de sincronización permiten la comunicación entre los procesos o hilos, basados en memoria compartida utilizando la semántica de acceso a memoria compartida, tales como son: Semáforos Monitores Mutex y Variables condicionales Candados Paso de Mensajes Canales Las operaciones de sincronización deben ser atómicas.

20 Tipos de mecanismo Semáforos: Son componentes pasivos de bajo nivel de abstracción que sirven para arbitrar el acceso a un recurso compartido. (Dijkstra, 1968). Secciones críticas: Son mecanismos de nivel medio de abstracción orientados a su implementación en el contexto de un lenguaje concurrente y que permiten la ejecución de un bloque de sentencias de forma segura. Tienen un nivel de abstracción mucho mas alto que los semáforos, y en consecuencia son más fáciles y seguros de manejar. (Brinch Hansen, 1972). Monitores: Son módulos de alto nivel de abstracción orientados a la gestión de recursos que van a ser usados concurrentemente. Resuelven internamente, el acceso de forma segura a una variable o a un recurso compartido por múltiples procesos concurrentes. Hoare,1974.

21 Estructura general de un Mecanismo de Sincronización La estructura general, por tanto, de cualquier mecanismo que pretenda resolver el problema de la sección crítica es la siguiente: Entrada en la sección crítica Código de la sección crítica Salida de la sección crítica

22 22 Desventajas Algoritmos de E. Mutua Los Algoritmos de E. Mutua presentan varios inconvenientes: Utilizan espera ocupada Requieren un análisis y programación muy cuidados Están muy ligados a la máquina en que se implementan No son transportables No dan una interfaz directa al programador Son poco estructurados Son difíciles de extender a un número arbitrario de entidades concurrentes

23 SEMÁFOROS

24 24 Semáforos: Definición y operaciones Definición: Un semáforo es una variable S entera que toma valores no negativos y sobre la que se pueden realizar dos operaciones. Son introducidos inicialmente por Djisktra. Es una estructura de datos abstracta que nos permiten el manejo de una región crítica. Operaciones soportadas: Wait (S): Si S>0 entonces S:=S- 1. En otro caso, la entidad concurrente es suspendida sobre S, en una cola asociada. Signal (S): Si hay una entidad concurrente suspendida se le despierta. En otro caso S:=S+1. Notación: Wait (S)=P(S) Init(S, valor). Da valor inical al Signal (S)=V(S) contador del semaforo

25 25 Generalidades Wait y Signal son atómicas El valor inicial de un semáforo es no negativo Signal despierta a algún proceso suspendido por el semaforo, no especificado por la definición Hipótesis de corrección Semáforos generales: S=>0 Semáforos binarios: S=0, 1 Ecuaciones de Invariancia: deben ser satisfechas por cualquier implementación:

26 26 Implemetación Semáforos Contador-integer Cola-lista 1. La variable S mantiene el valor actual del semáforo. 2. L es una estructura de datos, en principio dinámica. 3. Cuando S = 0 y un proceso llama a Wait es bloqueado y mantenido en la lista S 4. Cuando otro proceso señaliza sobre S, algunos de los bloqueados sale de L según algún algoritmo de prioridad

27 Tipos de Semáforos Semáforos binarios: Pueden tomar solo los valores 0 y 1. Semáforos general: Puede tomar cualquier valor Natural (entero no negativo).

28 Semáforo General Un semáforo general (contador) es un tipo de datos abstracto que tiene 2 operaciones para acceso: P y V, de los nombres originales que les puso Dijkstra (palabras holandesas passeren, pasar, y vrygeven, liberar). Tannenbaum las denomina down (abajo) y up (arriba) respectivamente).

29 Semáforos y POO En términos de la orientación a objetos un semáforo S se crea a partir de una clase que tiene un atributo privado de tipo número entero y una pareja de métodos públicos P y V. El funcionamiento de tales operaciones sobre S se define a continuación: Si el valor del contador S es positivo, un hilo al invocar P(S) decrementa a S en una acción atómica; de otra forma (S <= 0) el hilo espera (se bloquea). Si el hilo invoca a V(S) y no hay hilo alguno esperando por ese semáforo entonces el valor del contador S se incrementa atómicamente; de otra forma uno de los hilos en espera se libera y se le permite continuar ejecutando su código en las siguientes instrucciones de donde fue interrumpido (i.e. inmediatamente después de P(S) Las operaciones sobre el contador del semáforo deben realizarse atómicamente para evitar condiciones de contención

30 Semáforo Binario Un semáforo binario sólo puede tener valores de su contador entre 0 y 1. Cuando es iniciado con valor 1 permite resolver el problema de la exclusión mutua: Semáforo binario compartido mutex con valor inicial 1 en cada hilo: P(mutex); //preprotocolo Sección crítica V(mutex); //postprotocolo

31 Ventaja de los Semáforos Binarios Por tanto, los semáforos binarios sirven para dos propósitos: Sincronización de exclusión mutua Condición de sincronización: bloquear a los hilos hasta que alguna condición se haga verdadera u ocurra un evento: Semáforo binario compartido S En un hilo 1: En el otro Hilo2: If(!cond) P(S); V(S);

32 Ejemplo P-C variables compartidas por el consumidor y el productor int N, contador = 0; Semaphore S=0, mutex=1; //semáforos binários compartidos productor() Mientras (true) produce_elemento(); Si (contador == N) entonces P(S); //delay Introduce_en_buffer(); P(mutex); contador++; V(mutex); Si (contador == 1) V(S); //Despertar consumidor() Mientras(true) Si (contador == 0 P(S); //delay Quita_Elemento(); P(mutex); contador--; V(mutex); Si (contador == N-1) V(S); //Despertar Consume_Elemento(); P(S); //solicita un recurso Utiliza el recurso V(S); //libera al recurso P(S) para solicitar una unidad de recurso e invoca a V(S) para regresar dicho recurso.

33 Cómo funcionan los semáforos? La operación inicializa se debe llevar a cabo antes de que comience la ejecución concurrente de los procesos ya que su función exclusiva es dar un valor inicial al semáforo. Un proceso que corre la operación espera y encuentra el semáforo a 1, lo pone a 0 y prosigue su ejecución. Si el semáforo está a 0 el proceso queda en estado de espera hasta que el semáforo se libera.

34 Estados del Proceso y semáforos Un proceso en espera de un semáforo no está en ejecución, ni listo para pasar a dicho estado puesto que no tiene la CPU ni puede pasar a tenerla mientras que no se lo indique el semáforo. Tampoco es válido el estado suspendido, ya que este estado está pensado para que lo utilicen llamadas al sistema operativo para suspender o reactivar un proceso que no tiene por qué tener una conexión con los semáforos.

35 Transiciones de el estado de Espera- Wait() Cuando se ejecuta la operación señal puede haber varios procesos en la lista o cola, el proceso que la dejará para pasar al estado listo dependerá del esquema de gestión de la cola de tareas suspendidas que se haya implementado en el diseño del semáforo, por ejemplo: FIFO, etc. Si no hay ningún proceso en espera del semáforo este se deja libre (S := 1) para el primero que lo requiera. Espera Ejecución Señal Listo Suspendido Dormido Figura 1. Transiciones para el estado de espera

36 Exclusión Mutua con Semáforos La exclusión mutua se realiza fácilmente utilizando semáforos. La operación de espera (wait) se usará como procedimiento de bloqueo antes de acceder a una sección crítica y la operación señal(signal) como procedimiento de desbloqueo. Se utilizarán tantos semáforos como clases de secciones críticas se establezcan. P1 wait (S) ; Sección Crítica signal (S) ; P2 wait (S) ; Sección Crítica signal (S) ;

37 Sincronización con Semáforos El uso de semáforos hace que se pueda programar fácilmente la sincronización entre dos tareas. En este caso las operaciones espera y señal no se utilizan dentro de un mismo proceso sino que se dan en dos procesos separados. El que ejecuta la operación de espera queda bloqueado hasta que el otro proceso ejecuta la operación de señal. A veces se emplea la palabra señal para denominar un semáforo que se usa para sincronizar procesos. En este caso una señal tiene dos operaciones: espera y señal que utilizan para sincronizarse dos procesos distintos. Supongamos que un proceso quiere que se le notifique que ha tenido lugar un suceso determinado y que otro proceso es capaz de detectar que ha ocurrido dicho suceso.

38 Ejemplo: Procesos sincronizados mediante semáforos (* Sincronización con semáforo*) Procesos con semaforos Método de Sincronización; var S: semaforo; P1 (* Proceso que espera *) Inicio_P1 wait(s);... Fin_P1 P2 (* Proceso que señala *) Inicio_P1... signal(s);... Fin_P2; Sincronización con semáforo Inicia_Sincronización //Inicializa el semáforo S= 0; P1(S) P2(S) Fin_Sincronización Qué Proceso espera? Qué Proceso Inicia?

39 Cómo se realiza la sincronización usando los semáforos? El semáforo=0 de modo que cuando el proceso P1 ejecuta la operación de espera se suspende hasta que el proceso P2 ejecuta la operación señal. La sincronización se realiza perfectamente incluso si el proceso P2 ejecuta la operación señal antes de que el proceso P1 ejecute la operación de espera, ya que en este caso el proceso P2 incrementa el semáforo y permite que P1 decremente el semáforo y siga su ejecución cuando alcanza la operación espera.

40 Semáforos en Java Los semáforos pueden implantarse a nivel del usuario (usando espera ocupada, por ejemplo) o a nivel del SO (inhabilitando las interrupciones a nivel del kernel, Unix ofrece semáforos como parte de los llamados al sistema para comunicación interprocesos (IPC)). Los semáforos binarios o contadores no se encuentran disponibles como tales en Java, pero su construcción no es difícil ya que Java ofrece como mecanismo para sincronización entre hilos a los monitores (que se verán en la siguiente sección). Los semáforos utilizados para asegurar exclusión mutua son iniciados a 1 y sólo toman 2 valores: 1 indica cuando la SC se encuentra libre y 0 cuando está siendo ocupada.

41 Semáforos en Java Por lo tanto, pueden verse como candados (locks) con 2 operaciones: cerrar el candado (lock) y abrir el candado (unlock) (correspondiendo a las operaciones P y V respectivamente). Además de asegurar exclusión mutua (solo se permite que un hilo se apodere de un candado a la vez), también se puede utilizar a un semáforo binario para comunicación entre hilos, al bloquear a un hilo hasta que ocurra un evento que será causado por otro hilo. Semáforo binario compartido : S En un hilo 1: En el otro Hilo2: P(S); Wait() Signal(); V(S);

42 Clase Semphore class Semaphore private int contador; public Semaphore(int n) this.contador = n; //metodo de espera o P() public synchronized void WAIT() while(contador == 0) try wait(); catch (InterruptedException e) contador--; //fin de while //fin de WAIT //metodo de señal o V() public synchronized void SIGNAL() count++; notify();

43 EJEMPLO DE HOLA MUNDO

44 Cómo funciona el semáforo? Recurso Compartido Impresión del Mensaje Cuántos semáforos se necesita? Un solo semáforo de acuerdo al número de recursos compartidos Que realiza el semáforo? Establece el mecanismo de acceso al recurso compartido (exlusión mutua) por parte de dos hilos que tienen que enviar su mensaje

45 Establecer el semáforo Pre-Protocolo Semaphoro(S).WAIT Sección Critica Imprime Hilo el mensaje Post-protocolo Semaphoro(S).SIGNAL

46 Clase HolaMundo public class HolaMundo extends Thread //se crea el semaforo static private Semaphore semaforo = new Semaphore(1); static private int COUNT=0; String cadena; public HolaMundo(String cad) cadena=cad; public void run () semaforo.wait(); System.out.println(cadena); semaforo.signal(); try Thread.currentThread().sleep((int)(Math.random () * 100)); catch (InterruptedException e) public static void main (String args []) HolaMundo H = new HolaMundo("Hola"); HolaMundo M = new HolaMundo("Mundo"); H.start(); M.start();

47 Sincronización con Semáforos Los semáforos también se pueden utilizar en la sincronización de procesos. Consideremos los procesos P1 y P2 y que P2 no puede ejecutar d hasta que P1 no haya finalizado la ejecución de a. P1 : begin end a; b; P2 : begin end Se puede resolver el problema utilizando un semáforo, s, sobre el que los procesos P1 y P2 realizan las siguientes operaciones: P1 : P2 : begin begin end a; signal(s) b; c; d; c; wait(s) d; end

48 La especificación del problema puede determinar el número de primitivas de semáforo y su ubicación. Ejemplo: Consideremos los procesos P1, P2 y P3 y se quiere que P2 solo pueda ejecutar d si P1 ha ejecutado a y P3 ha ejecutado e. P1 : begin a; b; end P2 : begin c; d; end P3 : begin e; f; end Se puede resolver el problema utilizando un semáforo, s, con valor inicial 0?

49 P1 : begin end a; signal(s) b; P2 : begin end c; wait(s) wait(s) d; P3 : begin end e; signal(s) f; Si P1 se ejecuta dos veces más rápido, P2 podría ejecutar d sin que P3 hubiera ejecutado e. La solución correcta es utilizar dos semáforos, s y t, uno entre P1y P2 y otro entre P2 y P3 P1 : begin end a; signal(s) b; P2 : begin end c; wait(s) wait(t) d; P3 : begin signal(t) f; end e;

50 Semáforos de sincronización Un semáforo permite estableces grafos de precedencia. Asociaremos a cada rama un semáforo. Cuando se ejecutan las sentencias de un nodo, el proceso habilita todos los arcos que salen desde un nodo con un signal. Para ejecutarse espera a que estén habilitados todos los arcos que le preceden. Recuerda cuando se abren dos arcos se indica concurrencia. Cuando se unen dos arcos se indica un punto de sincronización. Las sentencias de S4 no se pueden ejecutar hasta que terminan las sentencias S2 y S3.

51 En el siguiente grafo se establecen a, b, c y d como semáforos y se muestra el uso de los semáforos. P1 VAR a,b,c,d: semaphore BEGIN COBEGIN BEGIN S1; signal (a); signal (b); END; BEGIN P2 P3 P4 END; BEGIN END; BEGIN END; wait(a); S2; signal(c); wait(b); S3; signal(d); wait(c); wait(d); S4; COEND; END;

52 Los semáforos de paso se inicializan siempre a cero de modo que se respete el orden de precedencia

53 Semáforos Mutex P1 : begin end a; signal(s) b; P2 : begin end c; wait(s) wait(t) d; P3 : begin signal(t) f; end e;

54 import java.io.*; class Procesos2 protected static final SemaforoBinario S = new SemaforoBinario(0); protected static final SemaforoBinario T = new SemaforoBinario(0); protected static final SemaforoBinario mutex = new SemaforoBinario(1); public static void main(string args[]) throws IOException try Thread P1 = new Thread(new proceso1()); Thread P2 = new Thread(new proceso2()); Thread P3 = new Thread(new proceso3()); P1.start(); P2.start(); P3.start(); Thread.sleep(10); catch (InterruptedException e)

55 class proceso1 extends Procesos2 implements Runnable public void run() mutex.wait(); System.out.println("Soy el proceso #1 y la instruccion A"); mutex.signal(); S.SIGNAL(); mutex.wait(); System.out.println("Soy el proceso #1 y la instruccion B"); mutex.signal(); class proceso2 extends Procesos2 implements Runnable public void run() mutex.wait(); System.out.println("Soy el proceso #2 y la instruccion C"); mutex.signal(); S.WAIT(); T.WAIT(); mutex.wait(); System.out.println("Soy el proceso #2 y la instruccion D"); mutex.signal();

56 class proceso3 extends Procesos2 implements Runnable public void run() mutex.wait(); System.out.println("Soy el proceso #3 y la instruccion E"); mutex.signal(); T.SIGNAL(); mutex.wait(); System.out.println("Soy el proceso #3 y la instruccion F"); mutex.signal();

57 Ejercicio: Semáforos Binarios Mutex P1, imprime A, pero espera a que primero se imprima una B P2, imprime B, después imprime C, pero para imprimir C tiene que esperar a que se imprima A y D P3, imprime D, pero tiene que esperar a que se imprima una B a) Diseñe el grafo b) Elabore la solución con semáforos en Java

58 class p2 extends Procesos1 implements Runnable public void run() try mutex.wait(); System.out.println("Soy el proceso #2 y la instruccion B"); Thread.sleep(5000); //System.out.flush(); mutex.signal(); SA.SIGNAL(); SD.SIGNAL(); catch (InterruptedException e) try SC.WAIT(); SC.WAIT(); mutex.wait(); System.out.println("Soy el proceso #2 y la instruccion C"); Thread.sleep(5); mutex.signal(); catch (InterruptedException e)

59 class p1 extends Procesos1 implements Runnable public void run() try SA.WAIT(); mutex.wait(); System.out.println("Soy el proceso #1 y la instruccion A"); Thread.sleep(5000); mutex.signal(); SC.SIGNAL(); mutex.signal(); catch (InterruptedException e) // System.err.println("interrupted out of sleep");

60 public class p3 extends Procesos1 implements Runnable public void run() try SD.WAIT(); mutex. WAIT(); System.out.println("Soy el proceso #3 y la instruccion D"); Thread.sleep(5000); //System.out.flush(); mutex.signal(); SC.SIGNAL(); catch (InterruptedException e)

61 import java.io.*; class Procesos1 protected static final SemaforoBinario SA = new SemaforoBinario(0); protected static final SemaforoBinario SD = new SemaforoBinario(0); protected static final SemaforoBinario SC = new SemaforoBinario(0); protected static final SemaforoBinario mutex = new SemaforoBinario(1); public static void main(string args[]) throws IOException try Thread P1 = new Thread(new p1()); Thread P2 = new Thread(new p2()); Thread P3 = new Thread(new p3()); P1.start(); P2.start(); P3.start(); Thread.sleep(300); catch (InterruptedException e) //System.out.println(" Termine..."); // System.exit(0);

62 EJERCICIOS ENTREGA DE PROGRAMAS EN LABORATORIO

63 Practica individual 1. Obtener las sentencias cobegin/end del grafo de precedencia siguiente utilizando semáforos. (ejemplo anterior) 2. Realizar el programa en Java que permita enviar los mensajes de cada proceso según entren a la sección critica mandando el mensaje soy el proceso #1 y la instrucción s# utilizando semáforos. (crear el semáforo)

64 Grafo Programa en Java

65 Actividad de Auto-aprendizaje Supongamos que tenemos 4 procesos (p1, p2, p3, p4), cada proceso realiza su tarea de forma simultáneamente (durante un tiempo indefinido) y posteriormente termina. Supongamos además que necesitamos que se ejecuten primero los procesos P1 y P3, y luego P2 y P4. Realizar el programa que muestre la ejecución de estos procesos con semáforos y contesta las preguntas. P1 P3 Grafo de procedencia P2 P4

66 Preguntas a resolver 1. Qué problemática se resolvió a utilizar los semáforos? 2. Cuántos semáforos se ocuparon, por qué? 3. Explica con tus propias palabras, la función del semáforo

67 67 Ejemplos 1. Supongamos que existen 4 montones de papel. Hay que tomar un papel de cada montón y agrupar los 4 juntos (este proceso se repite hasta que se acaban los 4 montones). 2. Uno que se encargue de formar los 4 grupos y los vaya agrupando (grapando). Esta claro que el proceso que agrupa no puede hacerlo hasta que no tenga un montón completo.

68 68 En Grapar Proceso 1: Amontonar Var S:semaforo Mesa: tipo L Proceso Amontonar Repetir toma 1 hoja de cada montón región mesa hacer deja el grupo de 4 hojas en la mesa fin_región Signal (s) Hasta que se acaban las hojas Proceso 2: Grapar Proceso Grapar repetir Wait(s) región mesa hacer toma un grupo de la mesa y otro de la grapa fin_región hasta que no queden montones por grapar

69 69 Problemas Clásicos a Resolver en Equipo 1. Realizar los programas concurrentes utilizando las primitivas de Java para sincronizar los procesos. 2. Realizar los programas concurrentes utilizando semáforos para sincronizar los procesos. 1. Programa Grapar 2. Programa Baño 3. Programa del Puente 4. Programa Camiones 5. Programa de Tribu o Caníbales 6. Lectores y escritores 7. Filósofos Comensales 8. Productor Consumidor 9. Barbero Dormilón 10. Estacionamiento. Fecha: 4/octubre/2012