T3 Semaforos

1

Programación Concurrente

Tema 3Sincronización con Semáforos

Grado en Informática

1

Bibliografía

Programación ConcurrenteProgramación Concurrente– J. Palma et al. Thomson, 2003,

Capítulo 4

Principles of Concurrent and Distributed Programming– M. Ben-Ari. Prentice Hall, 2006 (Segunda Edicion)

Capítulo 6The Little Book of Semaphores

– Allen B Downey

Presentación basada en textos de sidelab URJC. (Creative Commons)

2

2

Sincronización con Semáforos

¿Qué es un Semáforo? Exclusión MutuaSincronización Condicional– Sincronización de Barrera

Metodología de DesarrolloSincronización AvanzadaSincronización Avanzada

Comunicación con Buffer

Conclusiones

3

¿Qué es un Semáforo?

Dijkstra (1968), introdujo la primera primitiva de sincronización con espera pasiva y la llamó SemáforoSon herramientas de bajo nivel que permiten la sincronización condicional entre procesos y la exclusión mutua en el acceso a lasexclusión mutua en el acceso a las secciones críticas

Dijkstra (1930-2002)

4

3


Un semáforo es una Clase (Programación OrientadaUn semáforo es una Clase (Programación Orientada a Objetos) o Tipo Abstracto de Datos (Programación estructurada)

En la parte privada tiene un contador de permisos y un conjunto de procesos bloqueadosE l t úbli ti ét d ( di i t )En la parte pública tiene métodos (o procedimientos) para bloquear y desbloquear procesos dependiendo del contador de permisos del semáforo

5


Valores permitidos:– En general los valores permitidos para un

semáforo son enteros no negativos.– Cuando sólo admiten como valor 0 y 1 se

denominan semáforos binarios.

6

4


Operaciones:wait(s) y signal(s) (operaciones atómicas)

wait(s); – Si el valor del semáforo es mayor que 0 (s>0), se

decrementa una unidad y el proceso continúa su ejecución

– Si el valor del del semáforo es cero (s=0) el proceso suspende su ejecución, pasa al estado bloqueado y se añade al conjunto de procesos bloqueados en el semáforo

s := s - 1

7


Operaciones (cont.):

signal(s);

– Si no existen procesos bloqueados en el semáforo, incrementa éste y continúa la ejecución

s := s + 1

– Si existen procesos bloqueados en el semáforo, desbloquea algún proceso y continúa su ejecución

8

5


Se puede pensar en un semáforo como una caja de bolas– El contador corresponde al número de bolas que hay en la

caja– wait(s);

El proceso que ejecuta wait necesita llevarse una bola de la cajaSi no hay bolas, se bloquea hasta que haya

– signal(s); Siempre echa una bola a la cajaSi l ú b d b l l d blSi algún proceso estaba esperando bola, la coge y se desbloquea

9


Diferentes nombres para las operaciones wait y signalp p y g– Las operaciones de gestión del semáforo reciben diferentes

nombres dependiendo del sistema operativo, lenguaje de programación y/o librería.

acquire release Descripción

P V Los nombres que Dijkstra puso originalmente a las operacionesen holandés. V proviene de verhogen (incrementar) y P provienede portmanteau prolaag (intentar reducir)

10

de portmanteau prolaag (intentar reducir)

Down Up ALGOL 68, el kernel de Linux kernel y algunos libros de texto

Wait Signal PascalFC y algunos libros de texto

Pend Post

Procure Vacate Procure significa obtener y vacate desocupar

acquire release API java.util.concurrent.Semaphore (Java)

6


Tipos de SemáforosTipos de Semáforos – Según el valor que puede tomar

Semáforos Binarios (0 y 1)Semáforos Generales o No negativos

– Según la política de desbloqueoFIFO (First In, First Out): Los procesos se desbloquean en orden de llegadaAleatorio: Los procesos se desbloquean aletoriamente

11

Semáforos en Pascal-FC

Pascal-FC permite el tipo semaforo general (no ti )negativo)

Declaración y operaciones:– var s:semaphore;– wait(s); signal(s);

Son procedimientos que ejecutan los procesosSon instrucciones atómicas

– initial(s,valorInicial);Asigna un valor inicial (no negativo) al semáforo Solo se puede llamar en la parte secuencial del programa principal (fuera del cobegin coend)

12

7


Variables de tipo SemáforoVariables de tipo Semáforo

vars1,s2:semaphore;arraySemaforo:array [1..5] of semaphore;regSemaforo:record

Ejemplos varios de declaración:

gi:integer;s:semaphore;

end;

13


Sólo se pueden definir variables de tipo semáforo en el programa principalSe pueden pasar como parámetros a procesos, procedimientos y funciones, necesitan ser parámetros por referencia. (var en PascalFC)p p ( )

14

8


¿Qué es un Semáforo?¿Qué es u Se á o oSincronización Condicional

Exclusión MutuaSincronización Avanzada

Metodología de DesarrolloConclusionesConclusiones

15

Exclusión Mutua

El problema de la Exclusión Mutua– Sección Crítica

Representa una secuencia de instrucciones que debe ejecutar cada proceso sin que haya interferencia con la ejecución de instrucciones de las secciones críticas de los demás procesos. Normalmente se corresponde con la utilización de un cierto recurso común de acceso exclusivo.

S ió N C íti– Sección No CríticaRepresenta las sentencias que pueden ser ejecutadas concurrentemente por todos los procesos

16

9

Exclusión Mutua

Problema de la Exclusión MutuaProblema de la Exclusión Mutua

process proceso;begin

repeatpreprotocolo;seccion_critica;postprotocolo;

i iti

El preprotocolo y postprotocolo son instrucciones que deben ejecutar los procesos, para garantizar que el acceso a las secciones críticas se realizan

li d l i itseccion_no_critica;forever

end;

cumpliendo los requisitos que se le exigen a la soluciónSe asume que los procesos finalizan su ejecución fuera de la sección crítica

17

Exclusión Mutua

program excMutSem;

process type tProceso(var em: semaphore);beginrepeatwait(em); cont := cont +1 (* Sección Crítica *)signal(em);Ejemplo: ambos g ( );(* Sección No Crítica *)write('Seccion No Critica');

foreverend;

varmutex:semaphore;p1,p2:tProceso;cont : integer;

Ejemplo: ambos procesos acceden a una variable compartida cont.

Utilizamos un semáforo binario (inicializado a 1)

Si el valor del

BLP (06-07) 18

begininitial( mutex,1);cont := 0;cobeginp1(mutex);p2(mutex);

coend;end.

semáforo es 1 , la sección crítica está libre

Si el valor es 0, la sección crítica está ocupada por otro proceso18

10

Exclusión Mutua Generalizada(Multiplex)

Se tiene cuando el número de procesos queSe tiene cuando el número de procesos que pueden ejecutar la sección crítica a la vez es N> 1Se implementa con semáforos generales asignando inicialmente un valor N al semáforo

19

Exclusión MutuaGeneralizada

program multiplex;

process type tProceso(var acceso: semaphore);beginrepeat(* Preprotocolo *)wait(acceso); (* Sección Crítica *)write('SC ');(* Postprotocolo *)signal(acceso);(* Sección No Crítica *)write('SNC ');

foreverend;

varacceso:semaphore;p:array [1..5] of tProceso;

El valor del semáforo nos indica los “huecos libres” que quedan en la sección crítica

BLP (06-07) 20

i:integer;

begininitial(acceso,3);cobeginfor i:=1 to 5 dop[i](acceso);

coend;end.20

11


¿Qué es un Semáforo?¿Qué es u Se á o oSincronización Condicional

Exclusión MutuaSincronización Avanzada

Metodología de DesarrolloConclusionesConclusiones

21

Sincronización Avanzada

Todo programa concurrente se puede implementar conTodo programa concurrente se puede implementar con sincronizaciones condicionales y exclusiones mutuasExisten variantes de estas formas de sincronización que se utilizan habitualmente en la programación concurrenteEn este apartado se veremos las más usualesEn este apartado se veremos las más usuales

22

12

Sincronización Condicional

Se produce cuando un proceso debe esperar a que seSe produce cuando un proceso debe esperar a que se cumpla una cierta condición para proseguir su ejecuciónEsta condición sólo puede ser activada por otro proceso

PA1 PA2Proceso A PA1 PA2

PB1 PB2

Diagrama de Precedencia

Proceso A

Proceso B

23

SincronizaciónCondicional

Implementación

program sinccond;

process tPA(var continuar:boolean);begin

write('PA1 ');continuar := true;write('PA2 ');

end;Implementación con Espera Activa

PA1 PA2

Proceso A

process tPB(var continuar:boolean);begin

write('PB1 ');while not continuar do null;write('PB2 ');

end;

varcontinuar: boolean;

BLP (06-07) 24

PB1 PB2

Proceso B

procA:tPA; procB:tPB;begincontinuar := false;cobegin

procA(continuar);procB(continuar);

coend;end.24

13

program sinccond;

process tPA(var sc:semaphore);begin

write('PA1 ');signal(sc);write('PA2 ');

end;


I l t ió end;process tPB(var sc:semaphore);begin

write('PB1 ');wait(sc);write('PB2 ');

end;

varsc: semaphore;

Implementación con Semáforos

PA1 PA2

Proceso A

sc: semaphore;procA:tPA; procB:tPB;

begininitial(sc,0);cobegin

procA(sc);procB(sc);

coend;end. 25

PB1 PB2

Proceso B

25

Rendezvous

El Proceso A debe esperar al Proceso B y viceversaEl Proceso A debe esperar al Proceso B y viceversa

PA1 PA2Proceso A

26

PB1 PB2


Proceso B

14


I l t ió

program rendezvous;

process tPA;beginwrite('PA1 ');signal(aArraived);wait (bArraived);write('PA2 ');

end;Implementación con Semáforos

PA1 PA2

PB1 PB2

Proc A

P B

end;process tPBbeginwrite('PB1 ');signal(bArraived);wait(aArraived);write('PB2 ');

end;

varaArraived bArraived: semaphore;

2727

PB1 PB2


Proc B aArraived,bArraived: semaphore;procA:tPA; procB:tPB;

begininitial(aArraived,0);initial(bArraived,0);cobeginprocA; procB;

coend;end.

Sincronización de Barrera

La Sincronización de Barrera es una sincronizaciónLa Sincronización de Barrera es una sincronización condicional en la que los procesos tienen que esperar a que el resto de procesos lleguen al mismo punto para poder continuar su ejecuciónVamos a estudiar este tipo de sincronización con los siguientes requisitos

– Programa con N procesos– Cada proceso escribe la letra ‘A’ y luego la ‘B’Cada proceso escribe la letra A y luego la B– Los procesos tienen que esperar que todos hayan escrito la letra ‘A’ antes de escribir la ‘B’

28

15


process type tProceso;beginwrite('A');

wait(mutex); nProcesos := nProcesos + 1; {}signal (mutex); {}

{Rendezvous}if nProcesos = NPR then signal(sbarrera); {}

Aproximación

varproc: array [1..NPR] of tProceso;i:integer;

wait(sbarrera);write('B'); {Punto crítico}

end;

Incorrecta

Puede provocar interbloqueo (deadlock). El último desbloquea, pero sólo uno de los procesos que esperan pueden pasar begin

nProcesos := 0;initial(sbarrera,0);initial(mutex,1);cobeginfor i:=1 to NPR doproc[i];

coend;end.

const NPR=...var

mutex : semaphore;sbarrera: semaphore;nProcesos: integer;

pasar

29


process type tProceso;vari:integer;

beginwrite('A');

wait(mutexNP);nProcesos:= nProcesos + 1;

2ª AproximaciónI t nProcesos:= nProcesos + 1;

signal(mutexNP);

if nProcesos < NPR thenwait(sbarrera)

elsefor i:=1 to NPR-1 dosignal(sbarrera);

write('B'); end;

Incorrecta

Si se deja la consulta del contador fuera de la Exclusión Mutua, puede ocurrir que dos procesos hagan signal

initial(sbarrera,0);nProcesos := 0;initial(mutexNP,1);

signal

const NPR=...var

sbarrera: semaphore;nProcesos: integer;mutexMP: semaphore;

30

16


process type tProceso;vari:integer;

beginwrite('A');wait(mutexNP);nProcesos := nProcesos + 1;if nProcesos < NPR thenbegin1ª Solución

C t signal(mutexNP);wait(sbarrera);

endelsebeginsignal(mutexNP);for i:=1 to NPR-1 dosignal(sbarrera);

end; write('B');

end;

Correcta

Si el proceso no es el último libera la EM y se bloquea.

Si es el último, sale del mutex y desbloquea a los demás procesos

initial(sbarrera,0);nProcesos := 0;initial(mutexNP,1);

e d;demás procesos

31

const NPR=...var


No puede utilizarse en un bucle con reentrada podría producir inanición

Sincronización de Barrera process type tProceso;

vari:integer;

beginwrite('A');

wait(mutexNP);nProcesos := nProcesos + 1;2ª Aproximación

I t signal(mutexNP);if nProcesos = NPR thenfor i:=1 to NPR dosignal(sbarrera);

wait(sbarrera);

write('B'); end;

Incorrecta

Si se deja la consulta del contador fuera de la Exclusión Mutua, puede ocurrir que dos procesos hagan signal

initial(sbarrera,0);nProcesos := 0;initial(control.emNProcesos,1);

32

const NPR=...var



signal

17

Sincronización de Barrera process type tProceso;

vari:integer;

beginwrite('A');

wait(mutexNP);nProcesos := nProcesos + 1;1ª Solución nProcesos := nProcesos + 1;if nProcesos = NPR thenfor i:=1 to NPR dosignal(sbarrera);

signal(mutexNP);

wait(sbarrera);

write('B'); end;

Correcta

En la rama del if el proceso deja el semáforo preparado para cuando él mismo ejecute

i

initial(sbarrera,0);nProcesos := 0;initial(control.emNProcesos,1);

un wait

33

const NPR=...var




process type tProceso;beginwrite('A');

wait(mutex); nProcesos := nProcesos + 1; signal (mutex);

if nProcesos = NPR then signal(sbarrera);2ª Solución correcta turnstile

cont := 0;initial(barrera,0);initial(mutex,1);

wait(sbarrera); {Torno} signal(sbarrera); { }write('B');

end;

const NPR=...varmutex : semaphore;sbarrera: semaphore;nProcesos: integer;

correcta turnstile(Torno)

34

Torno: El patrón -un wait y un signal sucesivos- ocurre a menudo y tiene un nombre Turnstie (Torno), porque sólo permite el paso de un proceso a la vez y además permite ser bloqueado para parar todos los procesos.

Si inicialmente vale 0 el torno está bloqueado.

18

Barrera reutilizable

A menudo un conjunto de Hilos/Procesos que cooperanA menudo un conjunto de Hilos/Procesos que cooperan realizan una serie de pasos en un blucle y se sincronizan en una barrera cada vuelta.Para esta aplicación necesitamos una barrera reutilizable para la entrada y la salida

35

Barrera reutilizable (con Tornos)

process type tProceso;begin

repeatwrite('A');wait(mutex);

cont := cont+1;if (cont=NPR) thenbegin

wait(torno2); {bloquea el segundo torno}signal(torno1); {desbloquea el primero}

end;signal(mutex); Inicialmente el wait(torno1); {primer torno}signal(torno1);

write('B'); {Punto crítico}

wait(mutex);cont := cont-1;if (cont=0) thenbegin

wait(torno1); {bloquea el primero}signal(torno2); {desbloquea el segundo}

end;

primer torno está bloqueado y el segundo abierto.Cuando todos llegan al primero cerramos el segundo y b i l

initial(torno1,0);initial(torno2,1);initial(mutex,1);cont :=0;

end;signal(mutex);

wait(torno2); {segundo torno}signal(torno2);

forever;end;

abrimos el primero

torno1: semaphore;torno2: semaphore;mutex: semaphore;

cont : integer;36

19

Estudiantes Fumadores

Se desea implementar un ciclo de 4 procesos que se ejecuntanSe desea implementar un ciclo de 4 procesos que se ejecuntanconcurrentemente, cada proceso muestran Ax (siendo x el número del proceso) y se espera antes de salir a los demás. El último proceso muestra ‘-’ y desbloquea a los demásSi se necesita usar una única barrera en un bucle, debe tenerse control de los desbloqueos de los procesos

37

Barrera reutilizable (con Tornos)

process type tProceso;begin

write('A');wait(mutex);

cont := cont+1;if (cont<NPROCESOS) thenbegin

signal(mutex);wait(sb);signal(desbloqueo);

endelseInicialmente el else

signal(mutex);

wait(torno1); {primer torno}signal(torno1);

write('B'); {Punto crítico}

wait(mutex);cont := cont-1;if (cont=0) thenbegin

primer torno está bloqueado y el segundo abierto.Cuando todos llegan al primero cerramos el segundo y b i l

initial(torno1,0);initial(torno2,1);initial(mutex,1);cont :=0;

gwait(torno1); {bloquea el primero}signal(torno2); {desbloquea el segundo}

end;signal(mutex);

wait(torno2); {segundo torno}signal(torno2);

end;

abrimos el primero

sb: semaphore;desbloqueo: semaphore;mutex: semaphore;

cont : integer;38

20



Metodología de DesarrolloSincronización Avanzada


Conclusiones

39

Metodología de Desarrollo

A medida que los programas concurrentes se hacen másA medida que los programas concurrentes se hacen más complejos, se hace necesario seguir una metodología que permita guiar el desarrollo de los mismosA continuación se definen una serie de pasos que se pueden seguir para crear un programa concurrente partiendo de unos requisitos

40

21

Metodología de Desarrollo

1) Definir la arquitectura de los procesos Número de Procesos– Número de Procesos

– Tipo de Procesos

2) Implementar lo que tiene que hacer cada proceso de forma secuencial (en el lenguaje que utilicemos)3) Determinar los puntos de sincronización en el código

– ¿Sincronización Condicional o Exclusión Mutua?– Número de Semáforos Necesarios

¿Se pueden bloquear todos los procesos juntos? ¿Se puede desbloquear cualquiera de ellos?

4) Programación de wait y signal definiendo las variables necesarias para controlar la sincronización5) Gestión de variables

– Inicialización de booleanas a true/false, contadores a 0– Bajo Exclusión Mutua si son compartidas

41


Hasta ahora hemos visto cómo los procesos se comunicanHasta ahora hemos visto cómo los procesos se comunican con una variableEs habitual que los procesos se comuniquen con un buffer con varias posiciones para almacenar temporalmente informaciónEl buffer permite que se pueda ir insertando información aunque no esté preparado el proceso encargado de usarlaEl problema típico con el que se estudia la comunicación con buffer es

– El Problema de los Productores Consumidores

42

22

Comunicación con BufferProductores Consumidores

Procesos– Los Productores son procesos que generan datos– Los Consumidores son procesos que consumen los

datos en el orden en que se generanRestricciones

– Cada productor genera un único dato cada vez– Un consumidor sólo puede consumir un dato cuando

éste haya sido generado por el productoréste haya sido generado por el productor– Todos los productos se consumen

43


SincronizaciónSincronización– Los consumidores deben de bloquearse cuando no

tengan datos que consumir– Los productores deben bloquearse cuando el buffer

esté lleno

Comunicación– Se utilizará un buffer para almacenar los datos

producidos antes de ser consumidos

44

23


process type tProductor(var buffer:tBuffer);

varvarbuffer:tBuffer;i:integer;prod:array [1..5] of tProductor;cons:array [1..3] of tConsumidor;

begininicializar(buffer);cobeginfor i:=1 to 5 doprod[i](buffer);

vardato: integer;

beginrepeatdato := random(200);insertar(dato,buffer);

foreverend;

process type tConsumidor

45

prod[i](buffer);

for i:=1 to 3 docons[i](buffer);

coend;end.

(var buffer:tBuffer);vardato: integer;

beginrepeatsacar(dato,buffer);writeln(dato);

foreverend; 45


type tBuffer = recorddatos: array [1..MAXDATOS] of integer;posInser, posSacar:integer;

end;

procedure inicializar(var buffer:tBuffer);beginbuffer.posInser := 1;Buffer Circular pbuffer.posSacar := 1;

end;

procedure insertar(dato:integer; var buffer:tBuffer);

beginbuffer.datos[buffer.posInser]:= dato;buffer.posInser :=

buffer.posInser MOD MAXDATOS + 1;end;

**

posSacar

8

1 2

3

Buffer Circular

procedure sacar(var dato:integer; var buffer:tBuffer);

begindato:=buffer.datos[buffer.posSacar];buffer.posSacar :=

buffer.posSacar MOD MAXDATOS + 1;end;

**

posInser

4

56

7

46

24


Falta incorporar los puntos de sincronizaciónFalta incorporar los puntos de sincronización – Sincronización Condicional

Un productor se bloqueará antes de insertar un dato si el buffer está llenoUn consumidor se bloqueará antes de leer un dato si el buffer está vacío

Exclusión Mutua– Exclusión MutuaLas variables de control del buffer deben estar bajo exclusión mutua

47


Declaramos los semáforos necesariosDeclaramos los semáforos necesarios

Inicializamos los semáforos

type tBuffer = recorddatos: array [1..MAXDATOS] of integer;posInser, posSacar: integer;nProductos,nHuecos,em:semaphore;

end;

procedure inicializar(var buffer:tBuffer);begin

buffer.posInser := 1;buffer.posSacar := 1;initial(buffer.nProductos,0);initial(buffer.nHuecos,MAXDATOS);initial(buffer.em,1);

end;48

25


InsertarInsertarprocedure insertar(dato:integer; var buffer:tBuffer);begin

wait(buffer.nHuecos);

wait(buffer.em);buffer.datos[buffer.posInser]:= dato;buffer.posInser := buffer.posInser MOD MAXDATOS + 1;signal(buffer.em);

signal(buffer.nProductos);end;

49


SacarSacarprocedure sacar(var dato:integer; var buffer:tBuffer);begin

wait(buffer.nProductos);

wait(buffer.em); dato := buffer.datos[buffer.posSacar];buffer.posSacar := buffer.posSacar MOD MAXDATOS + 1;signal(buffer.em);

signal(buffer.nHuecos);end;

50

26



Metodología de DesarrolloSincronización AvanzadaSincronización Avanzada


Conclusiones

51

Conclusiones

Ventajas de los Semáforos– Permiten resolver de forma sencilla y eficiente

la sincronización de procesos concurrentes– Se pueden usar para implementar de forma

muy sencilla el problema de la Exclusión Mutua

– Están presentes en la mayoría de lenguajes yEstán presentes en la mayoría de lenguajes y librerías de soporte a la concurrencia

52

27

Conclusiones

Desventajas de los Semáforos– Son primitivas de muy bajo nivel– Omitir un simple signal lleva a interbloqueo– Omitir un simple wait lleva a la violación de la

Exclusión Mutua– Colocar las operaciones wait/signal en los lugares

no adecuados llevan a comportamientos erróneos del programap g

– No estructuran el código del programa (libertad total para acceder a las variables compartidas), lo que hace que los códigos sean difíciles de mantener y de rastrear errores

53

Conclusiones

Puesto que los semáforos tienen ciertas desventajas, existen otras herramientas de sincronización de espera pasiva conotras herramientas de sincronización de espera pasiva con mayor nivel de abstracción

– Modelo de Memoria CompartidaSemáforosMonitoresRegiones Críticas Regiones Críticas Condicionales Sucesos BuzonesRRecursos

– Modelo de Paso de MensajesEnvío asíncronoEnvío síncrono o cita simpleInvocación Remota o cita extendida

54

28

Problema de la Comida de los Filósofos (Dijsktra 1965)

EnunciadoEnunciado– Cinco filósofos dedican su vida a pensar y a comer (estas

dos acciones son finitas en el tiempo). Los filósofos comparten una mesa rodeada de cinco sillas, cada una de un filósofo. En el centro de la mesa hay comida y en la mesa cinco palillos y cinco platos.

– De vez en cuando, un filósofo siente hambre, se sienta y trata de coger los dos palillos que hay cerca de él y cometrata de coger los dos palillos que hay cerca de él y come sin soltar los palillos, cuando termina de comer suelta los palillos.

– El problema a solucionar es crear un ritual (algoritmo que permita comer a los filósofos)

55

Problema de la Comida de Filósofos (Enunciado)

1

0

23

4 01

23

4

56Los N palillos son los recursos compartidos por los filósofos.

29

Problema de la Comida de los Filósofos

Los filósofos representan procesos/hilos interactivosLos filósofos representan procesos/hilos interactivos que realizan el siguiente bucle:

process type filosofo (name : integer);beginrepeatPensar;

57

Coger palillos;Comer;Soltar Palillos;

foreverend;


Asumimos:– Cada filósofo tiene una variable local i que lo identifica con

valores (0..4)– De forma similar los palillos están numerados de 0 a 4.

Por lo tanto el filosofo i tiene el palillo i a la derecha y el i+1 a la izquierda

Limitaciones– Sólo 5 palillos (por los recortes de fondos de la Universidad)– Un filósofo necesita 2 palillos para comer– Un filósofo sólo puede coger el palillo de su izquierda y el de su

derechaPor tanto un filoso hambriento debe esperar a que su vecino suelte el palillo.

58

30


Suponemos que los filósofos saben como comer y p q ycomo pensar.. ,nuestro trabajo es hacer una versión de cogerPalillos y soltarPalillos que satisfaga las siguientes restricciones:

– Un palillo sólo puede estar en posesión de un filósofo al mismo tiempo (Exclusión mutua).

– Sólo puede comer si tiene los dos palillos (sincronización di i l)condicional)

– Debemos evitar el deadlock y el livelock– Debemos evitar el starvation de un filosofo esperando un

palillo.– Debe ser posible que más de un filósofo coma al mismo

tiempo59


1 Raliza una solución que consiga la exclusión1.Raliza una solución que consiga la exclusión mutua en el uso de los palillos. ¿Problema?

60

31

Problema de la Comida de los Filósofos (otras soluciones)

Solución 1:Solución 1:– Si como máximo N-1 filósofos se sientan a la

mesa.. al final uno siempre tendrá dos palillos– Usa un semáforo general para representar N-1

sillas disponiblesSolución 12– Evitar la espera circular.– Hacer uno de los filósofos diferente (zurdo).

61

Problema: Estudiantes Fumadores

Cuatro amigos están estudiando en la biblioteca cada x tiempo les apetece fumar pero no salen hasta que todos tienen ganas de fumar.Cuando al cuarto también le apetece fumar dice “Vamos a fumar”, desbloquea a los otros y salen a fumarEstán un rato fumando y vuelven a entrar, el proceso se repite.

62

Simula el problema con semáforos.Intenta realizarlo con un contador y una única barrera.

Documents

T3 Semaforos