Semaforos en java

54
MECANISMOS DE SINCRONIZACIÓN

description

Implementacion de semaforos en java asi como sus mecanismos de sincronizacion

Transcript of Semaforos en java

Page 1: Semaforos en java

MECANISMOS DE SINCRONIZACIÓN

Page 2: Semaforos en java

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

Page 3: Semaforos en java

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.

Page 4: Semaforos en java

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.

Page 5: Semaforos en java

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.

Page 6: Semaforos en java

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

Page 7: Semaforos en java

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

7

Page 8: Semaforos en java

SEMÁFOROS

Page 9: Semaforos en java

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

9

Page 10: Semaforos en java

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:

10

Page 11: Semaforos en java

Implemetación Semáforos

11

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

Page 12: Semaforos en java

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

Page 13: Semaforos en java

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

Page 14: Semaforos en java

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

Page 15: Semaforos en java

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

Page 16: Semaforos en java

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

Page 17: Semaforos en java

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

Page 18: Semaforos en java

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

Page 19: Semaforos en java

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.

Page 20: Semaforos en java

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

Page 21: Semaforos en java

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

Page 22: Semaforos en java

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.

Page 23: Semaforos en java

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?

Page 24: Semaforos en java

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

Page 25: Semaforos en java

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.

Page 26: Semaforos en java

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

Page 27: Semaforos en java

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

Page 28: Semaforos en java

EJEMPLO DE HOLA MUNDO

Page 29: Semaforos en java

¿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

Page 30: Semaforos en java

Establecer el semáforo • Pre-Protocolo

• Semaphoro(S).WAIT

• Sección Critica • Imprime Hilo el mensaje

• Post-protocolo • Semaphoro(S).SIGNAL

Page 31: Semaforos en java

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

Page 32: Semaforos en java

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

Page 33: Semaforos en java

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 ?

Page 34: Semaforos en java

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

Page 35: Semaforos en java

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.

Page 36: Semaforos en java

• 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

Page 37: Semaforos en java

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

Page 38: Semaforos en java

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

Page 39: Semaforos en java

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

Page 40: Semaforos en java

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

Page 41: Semaforos en java

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

Page 42: Semaforos en java

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

Page 43: Semaforos 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) {} } }

Page 44: Semaforos en java

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

Page 45: Semaforos en java

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

Page 46: Semaforos en java

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

Page 47: Semaforos en java

EJERCICIOS ENTREGA DE PROGRAMAS EN LABORATORIO

Page 48: Semaforos en java

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)

Page 49: Semaforos en java

Programa en Java Grafo

Page 50: Semaforos en java

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

Page 51: Semaforos en java

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

Page 52: Semaforos en java

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.

52

Page 53: Semaforos en java

En Grapar

53

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

Page 54: Semaforos en java

Problemas Clásicos a Resolver en Equipo

54

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.