sistemas operativos

1. 1
Tema 7: Concurrencia y
Sincronización
Sistemas Operativos

2. 2
Índice:
1. Suspensión y Reanudación
2. Semáforos
3. Propiedades y Características de los
Semáforos
4. Problemas Clásicos de Concurrencia
2
Tema
7:
Concurrencia
y
Sincronización

3. 3
Índice:
1. Suspensión y Reanudación
2. Semáforos
3. Propiedades y Características de los
Semáforos
4. Problemas Clásicos de Concurrencia
3
Tema
7:
Concurrencia
y
Sincronización

4. 4
1. Suspensión y Reanudación
Tema
7:
Concurrencia
y
Sincronización
 Primitivas más simples:
sleep ()
 Bloquea al proceso que la invoca
wakeup (int pid)
 Reanuda a proceso cuyo PID se indica
 ¿Y si dicho proceso no está sleeping?
• La llamada a wakeup() no tiene efecto
• Se recuerda la llamada para que el próximo sleep() que haga
el proceso no tenga efecto.
• Se trata como un error.

5. 5
1. Suspensión y Reanudación
Tema
7:
Concurrencia
y
Sincronización
 Implementación: ¡trivial!
sleep ()
 Nuevo estado proceso llamante: bloqueado
 Insertar en lista de procesos bloqueados
 Activar bit “sleeping” en PCB para indicar causa de
bloqueo
wakeup (int pid)
 Nuevo estado proceso despertado: preparado
 Quitar de lista de procesos bloqueados e insertar en
preparados
 Desactivar bit “sleeping” en PCB

6. 6
1. Suspensión y Reanudación
Tema
7:
Concurrencia
y
Sincronización
 Aplicando estas primitivas a resolver problemas en
la vida real: productor/consumidor.
while(true)
{
producir_elemento();
if (contador==N)
sleep();
almacenar_elemento();
contador++;
if (contador==1)
wakeup(consumidor);
}
productor
0
1
2
3
tabla
N-1
ins ext
contador=0
while(true)
{
if (contador==0)
sleep();
retirar_elemento();
contador--;
if (contador==(N-1))
wakeup(productor);
usar_elemento();
}
consumidor
contador=1
contador=2
contador=3
contador=N

7. 7
1. Suspensión y reanudación
Tema
7:
Concurrencia
y
Sincronización
 Problemas:
 Suspensión es incondicional
• ¡No hay atomicidad comprobación-acción!
 Procesos deben conocerse entre sí
 Un único estado de espera por proceso
• Procesos están “o despiertos o dormidos”
• Si proceso está dormido, no hay vinculación alguna con la
causa por la que está en dicho estado

8. 8
Índice:
1. Suspensión y Reanudación
2. Semáforos
3. Propiedades y Características de los
Semáforos
4. Problemas Clásicos de Concurrencia
8
Tema
7:
Concurrencia
y
Sincronización

9. 9
2. Semáforos
Tema
7:
Concurrencia
y
Sincronización
1. Concepto de semáforo
2. Implementación de semáforos
3. Semáforos en la práctica
4. Semáforos binarios

10. 10
2. Semáforos
Tema
7:
Concurrencia
y
Sincronización
1. Concepto de semáforo
2. Implementación de semáforos
3. Semáforos en la práctica
4. Semáforos binarios

11. 11
2.1 Concepto de semáforo
Tema
7:
Concurrencia
y
Sincronización
 E. W. Dijkstra (1.965)
 Semaforo = tipo abstracto de datos, que encapsula:
 Un contador entero
 Una lista de procesos bloqueados en el semáforo
 Operaciones sobre semáforos:
 down(s):
• si contador = 0, proceso se bloquea en semáforo
• decrementa contador
 up(s):
• Incrementa contador
• Si había algún proceso bloqueado en semáforo, reanuda uno
 ¡Ambas operaciones son atómicas!

12. 12
2.1 Concepto de semáforo
Tema
7:
Concurrencia
y
Sincronización
 Utilidad: proteger acceso a recursos compartidos
 A cada recurso compartido, se asocia semáforo con valor
inicial 1.
 Secciones críticas asociadas al recurso:
• Protocolo de entrada: down(s)
• Protocolo de salida: up(s)
 Ventajas:
 Robustez
• Comprobación/Acción son atómicas
 Procesos que se coordinan no necesitan conocerse entre sí
• Sólo necesitan conocer semáforos que comparten
 Flexibilidad
• Tanto semáforos como recursos compartidos

13. 13
2. Semáforos
Tema
7:
Concurrencia
y
Sincronización
1. Concepto de semáforo
2. Implementación de semáforos
3. Semáforos en la práctica
4. Semáforos binarios

14. 14
void down(semaforo s)
{
if (s->contador>0)
s->contador--;
else
{
insertar_en_lista (&s->bloqueados, getpid());
sleep();
}
}
2.2 Implementación de semáforos
Tema
7:
Concurrencia
y
Sincronización
struct s_semaforo
{
int contador;
listaproc bloqueados;
}
typedef s_semaforo *semaforo;
struct nodoproc
{
PID proceso;
struct nodoproc *sig;
}
typedef struct nodoproc *listaproc
void up(semaforo s)
{
if (lista_vacia(s->bloqueados))
s->contador++;
else
{
int pid=sacar_de_lista(s->bloqueados);
wakeup(pid);
}
}
semaforo CrearSemaforo(int valor);
void DestruirSemaforo(semaforo s);

15. 15
2. Semáforos
Tema
7:
Concurrencia
y
Sincronización
1. Concepto de semáforo
2. Implementación de semáforos
3. Semáforos en la práctica
4. Semáforos binarios

16. 16
2.3 Semáforos en la práctica
Tema
7:
Concurrencia
y
Sincronización
Productor/Consumidor con semáforos
while(true)
{
producir_elemento();
down(vacias);
down(excmut);
almacenar_elemento();
up(excmut);
up(llenas);
}
productor
0
1
2
3
tabla
N-1
ins ext
contador=0
while(true)
{
down(llenas);
down(excmut);
retirar_elemento();
up(excmut);
up(vacias);
consumir_elemento();
}
consumidor
excmut=1
vacias=N
llenas=0
down(excmut);
down(vacias);

17. 17
2. Semáforos
Tema
7:
Concurrencia
y
Sincronización
1. Concepto de semáforo
2. Implementación de semáforos
3. Semáforos en la práctica
4. Semáforos binarios

18. 18
2.4 Semáforos binarios
Tema
7:
Concurrencia
y
Sincronización
 Caso particular: semáforos con sólo dos estados:
 Abierto (true, 1, …)
 Cerrado (false, 0, …)
 Operaciones sobre semáforos binarios:
 down(s):
• si estado=cerrado, proceso se bloquea en semáforo
• estado=cerrado
 up(s):
• estado=abierto
• Si había algún proceso bloqueado en semáforo, reanuda uno
 ¿Son más potentes semáforos contadores que
semáforos binarios?

19. 19
void up(semaforo s)
{
down_b(s->exc);
++(s->contador);
if (s->contador <=0)
up_b(s->esp);
up_b(s->exc);
}
void down(semaforo s)
{
down_b(s->blqd);
down_b(s->exc);
--(s->contador);
if (s->contador >=0)
up_b(s->exc);
else
{
up_b(s->exc);
down_b(s->esp);
}
up_b(s->blqd);
}
2.4 Semáforos binarios
Tema
7:
Concurrencia
y
Sincronización
struct s_semaforo
{
int contador;
semaforo_b blqd; /* =abierto */
semaforo_b exc; /* =abierto */
semaforo_b esp; /* =cerrado*/
}
typedef s_semaforo *semaforo;

20. 20
Índice:
1. Suspensión y Reanudación
2. Semáforos
3. Propiedades y Características de los
Semáforos
4. Problemas Clásicos de Concurrencia
20
Tema
7:
Concurrencia
y
Sincronización

21. 21
3. Propiedades y Características de los Sem.
Tema
7:
Concurrencia
y
Sincronización
 Reglas generales:
 Si un semáforo controla sección crítica,
• Cerrar lo más tarde posible
• Abrir tan pronto como sea posible
 Secciones críticas anidadas:
• Evitar en la medida de lo posible
• down(a) y despues down(b)→ admisible si proceso que hace
up(b) no hace down(a)
 Selección proceso que se desbloquea up:
 No especificado
 Depende de implementación:
• FIFO, aleatorio, prioridad…
 Los programas nunca deben depender de este detalle!

22. 22
3. Propiedades y Características de los Sem.
Tema
7:
Concurrencia
y
Sincronización
 Granularidad: nº de recursos controlados por cada
semáforo
 Granularidad fina: un recurso por semáforo
 Granularidad gruesa: un semáforo para todos los recursos:

23. 23
3. Propiedades y Características de los Sem.
Tema
7:
Concurrencia
y
Sincronización
Granularidad fina:
 Ventajas:
 mayor grado de paralelismo
P1
P2
 Inconvenientes:
 mayor número de semáforos
 ¡Posibilidad de interbloqueo!
Granularidad gruesa:
 (inversa)

24. 24
Índice:
1. Suspensión y Reanudación
2. Semáforos
3. Propiedades y Características de los
Semáforos
4. Problemas Clásicos de Concurrencia
24
Tema
7:
Concurrencia
y
Sincronización

25. 25
4. Problemas Clásicos de Concurrencia
Tema
7:
Concurrencia
y
Sincronización
Los Filósofos Comensales
void filosofo (int i)
{
while(true)
{
pensar();
coger_tenedor(derecho(i));
coger_tenedor(izquierdo(i));
comer();
soltar_tenedor(derecho(i));
soltar_tenedor(izquierdo(i));
}
}

26. 26
4. Problemas Clásicos de Concurrencia
Tema
7:
Concurrencia
y
Sincronización
void filosofo (int i)
{
while(true)
{
pensar();
down (s);
coger_tenedor(derecho(i));
coger_tenedor(izquierdo(i));
comer();
soltar_tenedor(derecho(i));
soltar_tenedor(izquierdo(i));
up (s)
}
}
 ¿Una posible solución?

27. 27
4. Problemas Clásicos de Concurrencia
Tema
7:
Concurrencia
y
Sincronización
excmut
f[0]
f[1]
f[2]
f[3]
f[N]
void filosofo (int i)
{
while(true)
{
pensar();
coger_tenedores(i);
comer();
soltar_tenedores(i);
}
}
void coger_tenedores(int i)
{
down(excmut);
estado[i]= HAMBRIENTO;
probar(i);
up(excmut);
down(f[i]);
}
void soltar_tenedores(int i)
{
down(excmut);
estado[i]= PENSANDO;
probar(izquierdo(i));
probar(derecho(i));
up(excmut);
}
void probar (int i)
{
if ((estado[i]==HAMBRIENTO) && (estado[izquierdo(i) != COMIENDO)
&& (estado[derecho(i)] != COMIENDO)
{
estado[i]= COMIENDO;
up(f[i])
}
}