• Los procesos que ejecutan de forma Concurrente en un
sistema se pueden clasificar como procesos independientes 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.
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.
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.
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
7
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
SEMÁFOROS
9
Semáforos: Definición y operaciones
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. Definición:
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, inical al Signal (S)=V(S) semaforo
valor). Da contador
valor del
10
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 de Invariancia: deben ser • Ecuaciones satisfechas por cualquier implementación:
11
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
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() P(S); //solicita un recurso { Utiliza el recurso Mientras(true) V(S); //libera al recurs o { Si (contador == 0 P(S); //delay P(S) para solicitar una Quita_Elemento(); unidad de recurso e invoca a V(S) para P(mutex); regresar dicho recurso. contador--; V(mutex); Si (contador == N-1) V(S); //Despertar Consume_Elemento(); }}
¿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 EsperaWait()
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. Ejecución Espera
Señal Listo
Suspendido
Dormido
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 sig nal (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 Sincro nización; var S: semaforo; P1 (* Proceso que espera *)
Inicio_P1 wait(S); ....
Sincronización con semáforo Inicia_Sincronización //Inicializa el semáforo
S= 0; P1(S) P2(S) Fin_Sincronización
Fin_P1 P2 (* Proceso que señala *)
Inicio_P1 .... signal(S); .... Fin_P2;
¿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.
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: P(S); Wait()
En el otro Hilo2: Signal();
V(S);
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 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(); } }
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
P2 : begin a; b;
c; d;
end
end
• Se puede resolver el problema utilizando un semáforo, s, sobre el que los procesos P1 y P2 realizan las siguientes operaciones: P2 : begin
P1 : begin a; signal(s) b; end
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.
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 ?
P2 : begin
P1 : begin
c; wait(s) wait(s) d;
a; signal(s) b; end
P3 : begin e; signal(s) f; end
end
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 P2 : begin
P1 : begin
c; wait(s) wait(t) d;
a; signal(s) b; end
P3 : begin
end
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. VAR a, b, c, d: semaphor e BEGI N COBEGI N BEGI N
S1; s i gnal ( a ) ; s i gnal ( b ) ;
P1 END;
BEGI N P2
wai t ( a) ; S2; s i gnal ( c ) ; END;
P3
P4
BEGI N
wai t ( b) ; S3; s i gnal ( d ) ; END; BEGI N
wai t ( c ) ; wai t ( d) ; S4; END;
COEND; END;
• Los semáforos de paso se inicializan siempre a cero de
modo que se respete el orden de precedencia
Semáforos Mutex
P2 : begin
P1 : begin
c; wait(s) wait(t) d;
a; signal(s) b; end
P3 : begin
end
e; signal(t) f; end
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.
2.
Obtener las sentencias cobegin/end del grafo de precedencia siguiente utilizando semáforos. (ejemplo anterior) 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)
Grafo
Programa 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 Grafo de procedencia
P2
P4
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
52
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.
53
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 gr upo 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 gr upo de la mesa y otr o de la grapa
fin_región
hasta que no queden montones por grapar
