MECANISMOS DE SINCRONIZACIÓN

PROGRAMACIÓN CONCURRENTE Y PARALELA

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.

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.

Ejemplo • Realizar el incremento de N hasta 20, siendo la variable

compartida entre dos hilos, de forma sincronizada

Clase Recurso Compartido import java.io.*; public class Recurso_Compartido { private int contador; public Recurso_Compartido() { contador=0; } public synchronized void aumentar() { contador=contador+1; System.out.println ("numero es"+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: Numero=1 Hilo 1 Numero=2 Hilo 1 Numero=3 Hilo 1 …… Numero=1 Hilo 2

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(); } }

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.

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.

Sincronización y Comunicación • Métodos Sincronizados

public tipo synchronized nombre_metodo () { } public synchronized void aumentar() { while (entrada == false) { try { wait(); } catch (InterruptedException e) { } } entrada= false; notify (); }

Cambia a estado de espera

Sincronización

Comunicación

Comunica que ya esta libre la sección critica

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

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); } }

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.

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

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

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); } } }

• 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.

Actividad Colaborativa

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

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.

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.

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.

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

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

22

SEMÁFOROS

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

24

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:

25

Implemetación Semáforos

26

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

Contador-integer Cola-lista

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).

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).

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

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

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);

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) para solicitar una unidad de recurso e invoca a V(S) para regresar dicho recurso.

P(S); //solicita un recurso Utiliza el recurso V(S); //libera al recurso

¿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.

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.

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

Suspendido Listo

Ejecución

Dormido

Señal

Figura 1. Transiciones para el estado de espera

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) ;

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.

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?

¿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.

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.

En un hilo 1: En el otro Hilo2: P(S); V(S);

Semáforo binario compartido : S

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.

Wait() Signal();

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(); } }

EJEMPLO DE HOLA MUNDO

¿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

Establecer el semáforo • Pre-Protocolo

• Semaphoro(S).WAIT

• Sección Critica • Imprime Hilo el mensaje

• Post-protocolo • Semaphoro(S).SIGNAL

Clase HolaMundo 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(); } }

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; }

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 a; b; end

P2 : begin c; d; end

• Se puede resolver el problema utilizando un semáforo, s, sobre el que los procesos P1 y P2 realizan las siguientes operaciones:

P1 : begin a; signal(s) b; end

P2 : begin c; wait(s) d; end

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.

P2 : begin c; d; end

P1 : begin a; b; end

P3 : begin e; f; end

¿Se puede resolver el problema utilizando un semáforo, s, con valor inicial 0 ?

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 a; signal(s) b; end

P2 : begin c; wait(s) wait(s) d; end

P3 : begin e; signal(s) f; end

P1 : begin a; signal(s) b; end

P2 : begin c; wait(s) wait(t) d; end

P3 : begin e; signal(t) f; end

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.

• 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

wait(a); S2; signal(c);

END; BEGIN

wait(b); S3; signal(d);

END; BEGIN

wait(c); wait(d); S4;

END;

COEND; END;

P2

P3

P4

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

P1 : begin a; signal(s) b; end

P2 : begin c; wait(s) wait(t) d; end

P3 : begin e; signal(t) f; end

Semáforos Mutex

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) {} } }

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(); } }

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(); } }

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

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) {} } }

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"); } }

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) {} } }

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); } }

EJERCICIOS ENTREGA DE PROGRAMAS EN LABORATORIO

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)

Programa en Java Grafo

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

P2 P4

Grafo de procedencia

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

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.

67

En Grapar

68

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

Problemas Clásicos a Resolver en Equipo

69

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

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.