Sistemas Operativos Tema 7.

Concurrencia

1998-2012 Jos Miguel Santos Alexis Quesada Francisco Santana

1

Contenidos
n n n n

Sistemas concurrentes El problema de la seccin crtica Semforos Monitores

Bibliografa
n

Fundamentos de Sistemas Operativos

q

S. Candela, C.R. Garca, A. Quesada, F.J. Santana, J.M. Santos. Thomson, 2007 Captulo 3 J.T. Palma, M.C. Garrido, F. Snchez, A. Quesada Captulos 1, 2, 3, 4, 5 y 6 M. Ben-Ari. Prentice Hall, 1990 A. Burns, G. Davies. Addison-Wesley, 1993 Captulo 7
3

Programacin Concurrente
q q

Principles of Concurrent and Distributed Programming

q

Concurrent Programming
q q

Contenidos
n n n n

Sistemas concurrentes El problema de la seccin crtica Semforos Monitores

Modelo del sistema

n

Conjunto de procesos cooperativos

q q q q

Red de cajeros automticos Sistema de reserva de billetes Servidor de impresin ...

Qu es concurrencia?
n

Definicin de diccionario: coincidir en el espacio o en el tiempo dos o ms personas o cosas. En Informtica, se habla de concurrencia cuando hay una existencia simultnea de varios procesos en ejecucin. Ojo, concurrencia existencia simultnea no implica ejecucin simultnea.

Paralelismo y concurrencia
n

El paralelismo es un caso particular de la concurrencia. Se habla de paralelismo cuando ocurre la ejecucin simultnea de instrucciones.

Procesos cooperativos
n

Necesidades de sincronizacin y comunicacin Los procesos concurrentes tendrn necesidad de comunicarse informacin Adems, ser necesario en ocasiones detener a un proceso hasta que se produzca un determinado evento o se den ciertas condiciones sincronizacin

Tcnicas de sincronizacin
n

Basadas en memoria compartida

q q q q q

Inhibicin de Interrupciones Espera activa Semforos Regiones crticas Monitores Canales Buzones

Basadas en el paso de mensajes

q q

Ejemplo 1: modificacin concurrente de una variable

procedure Ejemplo1 is x:integer; procedure P1 is begin x:=x+10; end P1; procedure P2 is begin if x>100 then Put_Line (x); else Put_Line (x-50); end if; end P2;

begin x:=100; COBEGIN P1; P2; COEND; end Ejemplo1;

10

Ejemplo 2: bucles infinitos concurrentes

procedure Ejemplo2 is contador:integer; procedure Cuenta is begin loop espera a que pase un coche contador := contador+1; end loop; end Cuenta; procedure Imprime; begin loop espera una hora Put(Coches que han pasado: ); Put (contador); contador:=0 end loop; end Imprime;

begin contador:=0; COBEGIN Cuenta; Imprime; COEND; end Ejemplo2;

11

Ejemplo 3: bfer limitado

N: constant integer:=...; type elemento is ...; buffer: array(0..N-1) of elemento; entra,sale: mod N:=0; contador: integer range 0..N:=0;

Productor

Consumidor

loop producir_algo (elem); loop exit when contador<N; end loop; buffer(entra):=elem; entra:=entra+1; contador:=contador+1; end loop;

loop loop exit when contador>0; end loop; elem:=buffer(sale); sale:=sale+1; contador:=contador-1; consumir (elem); end loop;

12

Problema al modificar datos compartidos

n n

Ambas rutinas son correctas si se ejecutan por separado pero podran NO funcionar si se ejecutan de manera concurrente Supongamos que contador contiene en un momento dado el valor 5 y que las instrucciones contador=contador+1 y contador=contador-1 se ejecutan de forma concurrente (contador podra ser 4, 5 o 6!) contador = contador + 1 contador=contador-1 registro1 := contador; registro2 := contador; registro1 := registro1 +1; registro2 := registro2 -1; contador : registro1; contador := registro2; registro1 := contador registro1 := registro1+1 registro2 := contador registro2 := registro2 -1 contador := registro1 contador := registro2 (registro1= 5) (registro1 = 6) (registro2 = 5) (registro2 = 4) (contador = 6) (contador = 4)
13

T0: productor T1: productor T2: consumidor T3: consumidor T4: productor T5: consumidor

Contenidos
n n n n

Sistemas concurrentes El problema de la seccin crtica Semforos Monitores

14

Seccin crtica: modelo del sistema

n

N procesos intentan acceder a un recurso compartido en un bucle infinito:

loop Seccin_No_Crtica (SNC); Pre_Protocolo; Seccin_Crtica (SC); Post_Protocolo; end loop;

Seccin crtica: segmento de cdigo donde se accede a datos compartidos con otros procesos

15

Seccin crtica: modelo del sistema (2)

n

Nunca puede haber ms de un proceso en la seccin crtica (exclusin mutua) Los pre y post protocolos sern algoritmos para garantizar que se cumple la exclusin mutua

16

Requisitos de la solucin
n n

Exclusin mutua Progreso: si ningn proceso est en seccin crtica y hay procesos que desean entrar en su s.c., slo estos ltimos participarn en la decisin y sta se tomar en un tiempo finito. Espera limitada: hay un lmite para el nmero de veces que otros procesos pueden adelantarse a un proceso que quiere entrar en s.c.

17

Importante
n

Suponemos que cada proceso se ejecuta a una velocidad distinta de cero No podemos hacer suposiciones acerca de las velocidades relativas de los procesos

18

Solucin trivial: cortar la multiprogramacin

n

Si suspendemos la multiprogramacin, desaparece el problema de acceso a los datos compartidos pero perdemos todas las ventajas de la multiprogramacin Hay que buscar una solucin menos radical

19

Solucin del hardware: inhibir las interrupciones

n

Antes de que un proceso entre en su seccin crtica, se inhiben las interrupciones As es imposible que el proceso sea expulsado de la CPU mientras est accediendo al dato compartido Al salir de la SC, se rehabilitan las interrupciones

20

Inhibir las interrupciones: problemas

n

Mientras un proceso est en SC, se suspende toda la concurrencia en el sistema no se le da oportunidad a otros procesos que no estn accediendo al recurso compartido Esta tcnica no se puede implementar en un multiprocesador

21

Soluciones con espera activa

La sincronizacin se basa en que un proceso espera mediante la comprobacin continua de una variable, manteniendo ocupada la CPU.
n n

Soluciones Software Soluciones Hardware

22

Intento ingenuo: usar un indicador de disponibilidad

-- variable global -- indica si la seccin crtica est libre libre: boolean := true; -- cdigo que ejecuta cada proceso loop seccin no crtica loop exit when libre; end loop; libre := false; seccin crtica libre := true; end loop;
23

Primer intento serio: variable turno

(solucin para dos procesos)
turno: positive range 1..2 := 1; loop SNC1; loop exit when turno=1; end loop; SC1; turno:=2; end loop; loop SNC2; loop exit when turno=2; end loop; SC2; turno:=1; end loop;

proceso 1

proceso 2
24

Discusin del primer intento

n n n

Exclusin mutua? Espera limitada? Progreso?

25

Segundo intento: avisadores

libre1, libre2: boolean := true; loop SNC1; loop exit when libre2; end loop; libre1:=false; SC1; libre1:=true; end loop; loop SNC2; loop exit when libre1; end loop; libre2:=false; SC2; libre2:=true; end loop;

proceso 1

proceso 2
26

Tercer intento
libre1,libre2: boolean := true; loop SNC1; libre1:=false; loop exit when libre2; end loop; SC1; libre1:=true; end loop; loop SNC2; libre2:=false; loop exit when libre1; end loop; SC2; libre2:=true; end loop;

proceso 1

proceso 2

27

Algoritmo de Peterson FUNCIONA!!

libre1, libre2: boolean := true; turno: positive range 1..2 := 1; loop SNC2; libre2:=false; turno:= 1; loop exit when libre1 or turno=2; end loop; SC2; libre2:=true; end loop; loop SNC1; libre1:=false; turno:= 2; loop exit when libre2 or turno=1; end loop; SC1; libre1:=true; end loop;

28

Solucin para N procesos:

Algoritmo de la panadera (Lamport)

cogiendonumero: array(1..N) of boolean := (others=>false); num: array(1..N) of natural := (others=>0); loop - cdigo del proceso i Seccin no crtica (i); cogiendonumero(i):=true; num(i) := 1 + MAX(num(1) ... num(n)); cogiendonumero(i):=false; for j in 1..N loop loop exit when not cogiendonumero(j); end loop; loop exit when i=j or num(j)=0 or num(j)>num(i) or (num(j)=num(i) and j>i); end loop; end loop; Seccin crtica (i); numero(i):=0; end loop;
29

Soluciones hardware
n

Inhibir interrupciones (muy drstico) Instrucciones atmicas test-and-set o SWAP.

30

Instrucciones atmicas
n n

Inventadas en los aos 60. Permiten evaluar y asignar un valor a una variable de forma atmica.
n n

test-and-set(B): Pone B a true y devuelve el antiguo valor de B. (Evaluar-y-Asignar(B)) SWAP(A,B): Intercambia los valores de A y B. (Intercambiar(A,B))

Si disponemos de estas instrucciones, se simplifica muchsimo el problema de la seccin crtica.

31

Ejemplos de algoritmos
loop Seccin no crtica; loop exit when Test_and_Set(llave)=false; end loop; Seccin crtica; llave:=false; end loop;

usando swap
loop Seccin no crtica; aux:=true; -- variable local! loop Swap(llave,aux); exit when aux=false; end loop; Seccin crtica; llave:=false; end loop;

usando test-and-set

32

Solucin completa (test-and-set)

esperando: array(0..N-1) of boolean := (others => false);
cerradura: boolean := false;
j: mod N; llave:boolean; loop SNCi; esperando(i):=true; llave:=true; while esperando(i) and llave loop llave:=Test_and_Set(cerradura); end loop; esperando(i):=false; SCi; j:=i+1; while (j/=i) and not esperando(j) loop j:=j+1; end loop; if j=i then cerradura:=false; else esperando(j):=false; end if; end loop;
33

Contenidos
n n n n

Introduccin El problema de la seccin crtica Semforos Monitores

34

Semforos
n n

Edsger Dijkstra, 1965 Objetivo: herramienta universal para sincronizar procesos, que sirva como componente bsico para construir algoritmos concurrentes

35

Concepto de semforo
n

Dijkstra lo defini como una variable entera S con dos operaciones atmicas: P(S): esperar a que S>0;

S:=S-1;
n

V(S): S:=S+1; NOTA: el semforo no puede adquirir valores negativos

36

Semforos: otras notaciones

n n

P(s) = wait(s) = espera (s) V(s) = signal(s) = seal (s) (se utilizan varias notaciones para las operaciones de los semforos, pero todas significan lo mismo)

37

Ejemplo: seccin crtica resuelta con semforos

n

Usamos un nico semforo inicializado a uno.

begin Seccin no crtica wait(s) Seccin crtica signal(s) end;

38

Semforos: esperar por eventos y condiciones

n

Se asocia un semforo, inicializado a cero, al evento por el que queremos esperar. Cuando un proceso ha hecho que se cumpla una determinada condicin, lo indica ejecutando un signal(c). Un proceso esperar a que la condicin sea cierta mediante un wait(c).
P1 begin S1; signal(c); S2; end; P2 begin R1; wait(c); R2; end;
39

Semforos: ejercicios
n

Ejercicios
q

a.-) Resolver el problema de la seccin crtica con n procesos b.-) Resolver diversos problemas de sincronizacin
n

b.1.-) Sean P1 y P2 dos procesos concurrentes. Modificar el cdigo de ambos procesos de forma que el conjunto de sentencias R2 del proceso 2 se ejecute despus de que se haya ejecutado el conjunto de sentencias S1 del proceso 1. P1 begin S1; S2; end; P2 begin R1; R2; end;
40

Semforos: ejercicios
q

b.2.-) Realizar un pequeo programa que se ajuste al siguiente diagrama (o grafo) de precedencia (suponiendo que disponemos de las herramientas siguientes: sentencia concurrente cobegin/coend )

A B

C D

41

Semforos: ejercicios
q

b.3.-) Realizar un pequeo programa que se ajuste al siguiente diagrama (o grafo) de precedencia (suponiendo que disponemos de las herramientas siguientes: sentencia concurrente cobegin/coend y semforos)
A B C D

42

Semforos: implementacin con espera activa

n

Tambin llamados spinlocks

wait(s): while s<=0 do nada; s:=s-1; signal(s): s:=s+1;

43

Semforos: implementacin sin espera activa

n

Suponemos que el SO proporciona unas operaciones para bloquear y desbloquear procesos

type Semforo is record valor:integer; L: Lista<Proceso>; end record;

wait(s): s.valor := s.valor-1; if s.valor<0 then L.insertar(procesoActual); bloquear(procesoActual); end if;

signal(s): s.valor := s.valor+1; if s.valor<=0 then L.extraer(proceso); despertar(proceso); end if;

44

Semforos: la implementacin debe garantizar atomicidad

n

Es crtico que las operaciones se ejecuten de forma atmica Entorno uniprocesador:

q

Inhibir interrupciones Instrucciones hardware especiales Aplicar un algoritmo de seccin crtica con espera activa

Entorno multiprocesador:
q q

45

Semforos binarios
n

Los semforos vistos reciben el nombre de semforo general o semforo de conteo Un semforo que slo puede tomar los valores 0 y 1 recibe el nombre de semforo binario

46

Ejercicio
n

Implementacin de un semforo de conteo con semforos binarios

47

Problemas clsicos de sincronizacin

n n

Problema del bfer limitado Problema de los lectores y escritores

q q

1er problema: prioridad para los lectores 2 problema: prioridad para los escritores

Problema de los filsofos comensales

48

Bfer limitado
N: constant integer:=...; type elemento is ...; buffer: array(0..N-1) of elemento; entra,sale: mod N:=0; hayElementos: Semaphore :=0; hayHuecos: Semaphore :=N; cerradura: Semaphore :=1;

Productor

Consumidor

loop ... producir un elemento elem ... wait(hayHuecos); wait(cerradura); buffer(entra):=elem; entra:=entra+1; signal(cerradura); signal(hayElementos); end loop;

loop wait(hayElementos); wait(cerradura); elem:=buffer(sale); sale:=sale+1; signal(cerradura); signal(hayHuecos); ... consumir elemento elem ... end loop;
49

Lectores y escritores
n

Esquema til para gestionar el acceso a una base de datos:

q

q q

Puede haber varios lectores accediendo a la BD de forma concurrente Slo puede haber un escritor trabajando No puede haber lectores y escritores al mismo tiempo y si se puede, que no haya inanicin

50

Lectores y escritores: dos variantes

n

Primera variante: prioridad para los lectores

q

Si un escritor est esperando, se le pueden adelantar otros lectores Ojo, riesgo de inanicin para los escritores

Segunda variante: prioridad para los escritores

q

Si hay escritores esperando por la BD, los lectores que van llegando nuevos se deben esperar hasta que todos los escritores finalicen Ahora hay riesgo de inanicin para los lectores
51

Lectores y escritores: 1 variante

cerradura: Semaphore :=1; escritura: Semaphore :=1; nlectores: natural :=0;

Lector
loop wait(cerradura); nlectores:=nlectores+1; if nlectores=1 then wait(escritura); signal(cerradura); LEER DE LA BD; wait(cerradura); nlectores:=nlectores-1; if nlectores=0 then signal(escritura); signal(cerradura); end loop;

Escritor

loop wait(escritura); ESCRIBIR EN LA BD; signal(escritura); end loop;

52

Lectores y escritores: 2 variante

cerrojo : Semaphore := 1; escribiendo : boolean := false; nlec,nesc : natural := 0;

Lector
wait(cerrojo); while escribiendo or nesc>0 loop signal(cerrojo); wait(cerrojo); end loop; nlec := nlec + 1; signal(cerrojo); leer de la BD wait(cerrojo); nlec := nlec 1; signal(cerrojo);

Escritor

wait(cerrojo); nesc := nesc + 1; while escribiendo or nlec>0 loop signal(cerrojo); wait(cerrojo); end loop; nesc := nesc - 1; escribiendo := true; signal(cerrojo); escribir en la BD wait(cerrojo); escribiendo := false; signal(cerrojo);
53

Los filsofos

54

Los filsofos: modelo simple

palillo: array(0..4) of Semaphore := (others=>1); loop wait(palillo(i)); wait(palillo(i+1 mod 5)); ... COMER; ... signal(palillo(i)); signal(palillo(i+1 mod 5); ... PENSAR; ... end loop;

55

Filsofos: ojo al interbloqueo

n

La solucin anterior puede entrar en un estado de bloqueo mutuo entre todos los filsofos interbloqueo Posibles soluciones:
q q

Algoritmo asimtrico filsofos pares/impares Impedir a ms de cuatro filsofos entrar a pedir los palillos Coger los dos palillos de forma atmica (o coges los dos, o no coges ninguno)
56

Los semforos ayudan, pero tienen limitaciones

n

Los semforos son una herramienta de bajo nivel, que requiere un uso disciplinado y cuidadoso. Es muy fcil cometer errores de uso con semforos. Veamos algunos ejemplos

57

dnde est el fallo?

Sem = 0 P (sem) seccin crtica V (sem)

58

dnde est el fallo?

Sem = 1 void rutina_en_exclusion_mutua () { P (Sem) cdigo de seccin crtica if ( error ) return; ms cdigo de seccin crtica V (sem) }

59

Ms problemas
Dos procesos que acceden a recursos compartidos: qu ocurre al ejecutarlos al mismo tiempo?

Proceso 1 P (impresora) P ( disco )

usar disco e impresora

Proceso 2 P (disco) P ( impresora )

usar disco e impresora

V (disco) V (impresora)

V (impresora) V (disco)

60

Herramientas de alto nivel

n

Objetivo: introducir en el lenguaje de programacin herramientas de sincronizacin que sean ms seguras que los semforos Ejemplos:
q q

Regiones crticas Monitores y variables condicin

61

Regiones crticas condicionales

n n n n

Abstraccin de un bloque de cdigo que accede a recursos compartidos. Garantiza exclusin mutua. El cdigo slo se ejecuta si la condicin asociada a la regin crtica es cierta. Ejemplo:
region Bfer when Nelementos > 0 { // este cdigo se ejecuta en exclusin mutua // y slo se ejecuta si Nelementos > 0 consumir un elemento del bfer Nelementos = Nelementos 1; }
62

Regiones crticas condicionales

n n n

Se plantearon en 1972 (Brinch Hansen, Pascal Concurrente) Gran fuerza expresiva, el cdigo queda mucho ms legible y compacto Problema: implementacin muy costosa, comparada con el cdigo escrito a mano con semforos Por ese motivo, nunca llegaron a prosperar como herramienta de uso comn

63

Contenidos
n n n n

Introduccin El problema de la seccin crtica Semforos Monitores

64

Monitor
n n

Propuesto por Hoare (1972) Tipo abstracto de datos

q q

Estructura de datos privada Operaciones pblicas Exclusin mutua Sincronizacin (variables condicin)

+
q q

65

Monitor: ejemplo bsico

monitor Contador { // operaciones pblicas public Contador () { valor = 0; } public void incrementa() { valor++; } public int actual() { return valor; } int valor; // variable interna privada }; Contador.incrementa(); V = Contador.actual();

Si varios procesos intentan manipular el monitor al mismo tiempo, van entrando de uno en uno: no puede haber ms de un proceso trabajando con el monitor en cada momento.
66

Monitor: estructura interna

67

Variables condicin
n

Una variable condicin sirve para gestionar una cola de espera por el monitor Dos operaciones
q

x.wait bloquea al proceso y lo mete en la cola x x.signal desbloquea a un proceso de la cola x; si no hay procesos en x, no hace nada

68

Variables condicin: ejemplo

monitor Contador { Condition cola; public Contador () { valor = 0; } public void BloqueaHastaQueValgaDiez() { if ( valor < 10 ) { cola.wait(); } } public void Incrementa() { valor++; if ( valor == 10 ) { cola.signal(); } } int valor; };

69

Monitor con variables condicin

datos compartidos

colas asociadas a las variables condicin x e y

x y

cola de ingreso

...
operaciones cdigo de inicializacin

70

Qu ocurre tras un signal

n

Qu ocurre cuando un proceso P realiza una operacin signal sobre una variable condicin x y existe un proceso suspendido Q asociado a dicha variable?
n n

Estilo Hoare se reanuda Q inmediatamente Estilo Mesa Q se desbloquea, pero espera a que P abandone el monitor

El estilo Mesa es el ms utilizado en los lenguajes de programacin actuales

71

Qu ocurre tras un signal (2)

n

Si varios procesos estn suspendidos por la condicin x y algn proceso ejecuta x.signal, qu proceso se reanuda?
q q

FIFO desbloqueamos al ms antiguo Por prioridades conveniente en sistemas de tiempo real

72

Ejemplo: un semforo implementado con un monitor

monitor Semforo { int valor; Condition cola; public Semforo (int val) { valor = val; } public void P() { while ( valor == 0 ) { cola.wait(); } valor--; } public void V() { valor++; cola.signal(); } };

73

Ejemplo: bfer limitado

monitor Bfer { Condition hayHuecos, hayItems; int nitems = 0; const int N = ; public void insertar (Item x) { while ( nitems==N ) { hayHuecos.wait(); } introducir x en el bfer nitems++; hayItems.signal(); } public Item extraer() { while ( nitems==0 ) { hayItems.wait(); } Item x = extrae algo nitems--; hayHuecos.signal(); return x; } };
74

Cmo se implementa un monitor

monitor MiMonitor { public void oper1 () { } public void oper2 () { } }; class MiMonitor { Semforo cerrojo = 1; public void oper1 () { cerrojo.P(); cuerpo de oper1 cerrojo.V(); } public void oper2 () { cerrojo.P(); cuerpo de oper2 cerrojo.V(); } };
75

El compilador genera un cdigo parecido a este:

El cerrojo garantiza que no puede haber ms de un proceso dentro del monitor

Cmo se implementa un monitor: variables condicin

monitor MiMonitor { Condition c; c.wait(); c.signal(); }; monitor MiMonitor { Semforo cerrojo = 1; Semforo c_queue = 0; int c_count = 0; c_count++; cerrojo.V(); // 1. libero el monitor c_queue.P(); // 2. me bloqueo en la cola cerrojo.P(); // 3. cuando me desbloqueen // debo recuperar el monitor

if (c_count>0) { // si hay alguien esperando c_count--; // lo desmarco c_queue.V(); // y lo desbloqueo }

76

Monitores: ejemplos ms avanzados

77

Lectores y escritores (1)

monitor BaseDatos { public EmpiezaLectura() { } public TerminaLectura() { } public EmpiezaEscritura() { } public TerminaEscritura() { } }; void Leer() { // Lo que debe ejecutar un lector BaseDatos.EmpiezaLectura(); leer de la BD BaseDatos.TerminaLectura(); } void Escribir() { // Lo que debe ejecutar un escritor BaseDatos.EmpiezaEscritura(); escribir en la BD BaseDatos.TerminaEscritura(); }
78

Lectores y escritores (2)

monitor BaseDatos { Condition leer, escribir; int nlec=0, lecesperan=0; bool escribiendo = false; public EmpiezaLectura() { while (escribiendo) { lecesperan++; leer.wait(); lecesperan--; } nlec++; leer.signal(); // desbloquea en cadena al resto } public TerminaLectura() { nlec--; if (nlec==0) { escribir.signal(); } }
79

Lectores y escritores (y 3)
public EmpiezaEscritura() { while (nlec>0 || escribiendo) { escribir.wait(); } escribiendo = true; } public TerminaEscritura() { escribiendo = false; if (lecesperan > 0) { leer.signal(); } else { escribir.signal(); } } };

80

Filsofos (1): especificacin del monitor

monitor MesaFilsofos { // estado interno del sistema const int N=5; Condition puedeComer[N]; enum Estado { pensando, hambriento, comiendo }; Estado estado[N] = { others => pensando }; // operaciones pblicas (ver siguientes pginas) public CogePalillos ( int filosofo ) { } public SueltaPalillos ( int filosofo ) { } // operacin auxiliar interna private compruebaQuePuedeComer ( int filosofo ) { } };

81

Filsofos (2): ejemplo de uso

void VidaDelFilsofo ( int unFilosofo ) { loop { piensaUnPoco(); MesaFilsofos.CogePalillos (unFilosofo); comeArroz(); MesaFilsofos.SueltaPalillos (unFilosofo); } }

82

Filsofos (3): rutina auxiliar

// operacin privada dentro del monitor MesaFilsofos private compruebaQuePuedeComer ( int filosofo ) { int vecinoDerecha = (filosofo+1) % N; int vecinoIzquierda = (filosofo-1+N) % N; if ( estado[vecinoIzquierda] != comiendo && estado[vecinoDerecha] != comiendo ) { estado[filosofo] = comiendo; puedeComer[filosofo].signal(); } }

83

Filsofos (y 4): operaciones pblicas del monitor

public CogerPalillos ( int filosofo ) { estado[filosofo] = hambriento; compruebaQuePuedeComer(filosofo); if ( estado[filosofo] != comiendo ) { puedeComer[filosofo].wait(); } } public SoltarPalillos ( int filosofo ) { estado[filosofo] = pensando; int vecinoDerecha = (filosofo+1) % N; int vecinoIzquierda = (filosofo-1+N) % N; compruebaQuePuedeComer (vecinoDerecha); compruebaQuePuedeComer (vecinoIzquierda); }

84