Clase Sincronizacion

Sistemas Operativos
Oscar Bedoya
oscarbed@eisc.univalle.edu.co
* Sincronización de procesos
* Sección crítica
* Semáforos
* Sincronización en Java
Sincronización de procesos
• Suponga un archivo cuyos registros están compuestos de los

siguientes cuatro campos:
Cédula Salario Dirección Teléfono

1152984120 4.000.000 Calle 13 # 339 1745
100 - 00
10066044 5.800.000 Calle 25 # 336 4346
25 A 44
• Se tienen dos tipos de procesos:

- Lectores
- Escritores
• Los problemas se presentan cuando los procesos obtienen acceso a

datos compartidos modificables
• Debe existir una sincronización entre procesos de tal manera que
cuando se esté modificando un registro, se impida el acceso al dato.
Esta sincronización se conoce como exclusión mutua
Problema del restaurante Chino

colocarPedido() atenderPedido()
cantidad
Cocinero 3 Mensajero
El proceso Mensajero
intenta tomar 2 pedidos. Si
solo hay 1 ó 0 espera hasta
que por lo menos hayan dos
Cocinero (Thread) Mensajero (Thread)
Mesa mesa; Mesa mesa;
run() run()
usa usa
Mesa Programa
int cantidad usa
Mesa mesa;
colocarPedido() Cocinero procesoCocinero;
atenderPedido() Mensajero procesoMensajero;
main()
public class Mesa{
int cantidad;
public Mesa(){
cantidad=0;
}
public void colocarPedido(){

cantidad=cantidad+1;
}
public void atenderPedido(){

while (cantidad<2)
;
cantidad=cantidad-2;
}
}
public class Mesa{
int cantidad;
• Cocinero y Mensajero comparten
la variable cantidad
public Mesa(){
cantidad=0;
}

}

while (cantidad<2)
;
cantidad=cantidad-2;
}
}
public class Mesa{
1 cantidad 3
int cantidad;
public Mesa(){
cantidad=0;
}

cantidad=cantidad+1; 2
}

while (cantidad<2)
;
cantidad=cantidad-2; 3
}
public class Mesa{
1 cantidad 3
int cantidad;
public Mesa(){
cantidad=0;
}
public void colocarPedido(){ register1=cantidad

cantidad=cantidad+1; 2 register1=register1+1
} cantidad=register1

while (cantidad<2)
; register2=cantidad
cantidad=cantidad-2; 3 register2=register2-2
}
1 cantidad 3
r1 r2 c
register1=cantidad
0 0 3
2 register1=register1+1
cantidad=register1
register2=cantidad
3 register2=register2-2
cantidad=register2
1 cantidad 3
r1 r2 c
register1=cantidad
3 0 3
cantidad=register1
register2=cantidad
cantidad=register2
1 cantidad 3
register1=cantidad
r1 r2 c
4 0 3
cantidad=register1
register2=cantidad
cantidad=register2
1 cantidad 3
register1=cantidad
r1 r2 c
4 0 4
cantidad=register1
register2=cantidad
cantidad=register2
1 cantidad 3
register1=cantidad
cantidad=register1
r1 r2 c
register2=cantidad
4 4 4
cantidad=register2
1 cantidad 3
register1=cantidad
cantidad=register1
register2=cantidad
r1 r2 c
4 2 4
cantidad=register2
1 cantidad 3
register1=cantidad
cantidad=register1
register2=cantidad
3 register2=register2-2 r1 r2 c
cantidad=register2 4 2 2
1 cantidad 3
register1=cantidad
cantidad=register1
register2=cantidad
cantidad=register2 cantidad 2
Si TODAS las instrucciones se

ejecutaran secuencialmente
1 cantidad 3
register1=cantidad register2=cantidad
2 register1=register1+1 3
register2=register2-2
cantidad=register1 cantidad=register2
1 cantidad 3
register1=cantidad
register2=cantidad
cantidad=register1
cantidad=register2
1 cantidad 3
r1 r2 c
register1=cantidad 3 0 3
register2=cantidad
cantidad=register1
cantidad=register2
1 cantidad 3
register1=cantidad r1 r2 c
2 register1=register1+1 4 0 3
register2=cantidad
cantidad=register1
cantidad=register2
1 cantidad 3
register1=cantidad
2 register1=register1+1 r1 r2 c
register2=cantidad
4 3 3
cantidad=register1
cantidad=register2
1 cantidad 3
register1=cantidad
register2=cantidad
r1 r2 c
4 1 3
cantidad=register1
cantidad=register2
1 cantidad 3
register1=cantidad
register2=cantidad
register2=register2-2 r1 r2 c
cantidad=register2
1 cantidad 3
register1=cantidad
register2=cantidad
cantidad=register1 r1 r2 c
1 cantidad 3
register1=cantidad
register2=cantidad
cantidad=register1
cantidad=register2
cantidad 1
1 cantidad 3
register1=cantidad
register2=cantidad
cantidad=register1
cantidad=register2
cantidad 1
El valor incorrecto para cantidad
se presenta porque se permite
que ambos hilos manipulen la
variable cantidad de manera
concurrente
1 cantidad 3
r1=0 r2=3 c=3

register2=cantidad
2 register1=cantidad
register1=register1+1
cantidad=register2
cantidad=register1
cantidad ?
Indique el valor de cantidad al
final de la ejecución
1 cantidad 3
r1=0 r2=3 c=3

register2=cantidad
2 register1=cantidad r1=3 r2=3 c=3
register2=register2-2 r1=3 r2=1 c=3

register1=register1+1 r1=4 r2=1 c=3
cantidad=register2 r1=4 r2=1 c=1
cantidad=register1
r1=4 r2=1 c=4
cantidad 4
public class Mesa{
1 cantidad 3
int cantidad;
public Mesa(){
cantidad=0;
}


while (cantidad<2)
}
• La parte del código que no puede ser interrumpida por otro proceso
(p. ej modificar un registro, modificar una variable compartida) se
denomina sección crítica
• Cuando un hilo o proceso se ejecuta en su sección crítica, ningún
otro proceso puede acceder a la misma parte del código
Sincronización
Los algoritmos que se han propuesto para permitir sincronización
entre procesos se pueden clasificar en tres grupos:
1. Espera activa
2. Espera no activa*
3. Mecanismos hardware
public class Mesa{
int cantidad;
public Mesa(){
cantidad=0;
}

}
public void atenderPedido(){ Acá se presenta espera activa,

while (cantidad<2) es decir, el proceso sigue
; compitiendo por procesador aun
cantidad=cantidad-2; cuando no lo necesita
}
}

cantidad
atenderPedido()
colocarPedido()
Cocinero Mensajero
Mensajero
Cocinero
atenderPedido()
colocarPedido()
Semáforos
(Dijkstra 1965)
Dijkstra
(1930 – 2002)
Proceso 1 Proceso 3
Proceso 4
Proceso 2
Proceso 5
S:3
pedir
Proceso 1 Proceso 3
Proceso 4
Proceso 2
Proceso 5
S:3
Proceso 1 Proceso 3
Proceso 4
Proceso 2
Proceso 5
S:2
Proceso 1 Proceso 3
Proceso 4
Proceso 2
pedir
Proceso 5
S:2
Proceso 1 Proceso 3
Proceso 4
Proceso 2
Proceso 5
S:1
Proceso 1 Proceso 3
Proceso 4
Proceso 2
devolver
Proceso 5
S:2
Proceso 1 Proceso 3
Proceso 4
Proceso 2
pedir
Proceso 5
S:2
Proceso 1 Proceso 3
Proceso 4
Proceso 2
Proceso 5
S:1
pedir
Proceso 1 Proceso 3
Proceso 4
Proceso 2
Proceso 5
S:1
Proceso 1 Proceso 3
Proceso 4
Proceso 2
Proceso 5
S:0
Proceso 1 Proceso 3
Proceso 4
pedir
Proceso 2
Proceso 5
El proceso 2 espera a
que alguien devuelva
un recurso
S:0
Proceso 1 Proceso 3
pedir
Proceso 4
pedir
Proceso 2
Proceso 5
El proceso 2 espera a
que alguien devuelva El proceso 4 espera a
un recurso que alguien devuelva un
recurso
S:0
Proceso 1 Proceso 3
pedir
Proceso 4
pedir
Proceso 2
Proceso 5
Valor actual del

S:0 semáforo
Un semáforo es una variable entera que tiene dos operaciones:
- P(). Permite pedir un recurso. Disminuye en 1 el valor del semáforo

si hay recursos disponibles. Sino lo obliga a esperar
- V(). Permite indicar que hay un recurso más disponible. Aumenta

en 1 el valor del semáforo
P()
Proceso 1 Proceso 3
Proceso 4
Proceso 2
Proceso 5
S:2
Proceso 1 Proceso 3
Proceso 4
Proceso 2
Proceso 5
S:1
Proceso 1 Proceso 3
Proceso 4
Proceso 2
V()
Proceso 5
S:2
Proceso 1 Proceso 3
Proceso 4
P()
Proceso 2
Proceso 5
S:0
Semaforo
int valor;
P()
V()
public class Semaforo{
int valor;
En el constructor se indica
public Semaforo(int v){ la cantidad de recursos
iniciales del semáforo
valor = v;
}
public void P(){
public void V(){
}
}
Proceso 1 Proceso 3
Recurso
Recurso Proceso 4
Proceso 2 Recurso
Proceso 5
semáforo1: 3
Proceso 1 Proceso 3
Recurso
Recurso Proceso 4
Proceso 2 Recurso
Proceso 5
semáforo1: 3
Semaforo semaforo1=new Semaforo(3);

Proceso 1 Proceso 3
Recurso
Recurso Proceso 4
Proceso 2 Recurso
Proceso 5
semáforo1: 3
Semaforo semaforo1=new Semaforo(3);

Crea un semáforo que permite
sincronizar 3 recursos
semaforo1.P();
Proceso 1 Proceso 3
Recurso
Recurso Proceso 4
Proceso 2 Recurso
Proceso 5
semáforo1: 3
semaforo1.P(): si hay un recurso disponible se concede y se

disminuye en 1 el semáforo, sino, espera a que alguien libere
alguno
Proceso 1 Recurso Proceso 3
Recurso
Recurso Proceso 4
Proceso 2
Proceso 5
semáforo1: 2
semaforo1.V();
Proceso 1 Recurso Proceso 3
Recurso
Recurso Proceso 4
Proceso 2
Proceso 5
semáforo1: 2
semaforo1.V(): indica que hay un recurso más disponible. El

semáforo se aumenta en 1
Proceso 1 Proceso 3
Recurso
Recurso Proceso 4
Proceso 2 Recurso
Proceso 5
semáforo1: 3
Proceso1: Proceso2: Proceso3:
public void run(){ public void run(){ public void run(){
... ... semaforo.P();
semaforo.P(); ... imprime(“1”)
imprime(“a”); semaforo.P(); imprime(“2”)
imprime(“b”); imprime(“I”) imprime(“3”)
imprime(“c”); imprime(“II”) imprime(“4”)
imprime(“d”); imprime(“III”) semaforo.V();
imprime(“e”); imprime(“IV”) }
imprime(“f”); semaforo.V();
imprime(“g”); }
imprime(“h”);
semaforo.V();
}
Semaforo semaforo=new Semaforo(2);

imprime(“g”); }
imprime(“h”);
semaforo.V();
}

Si se ejecutan los tres procesos al tiempo, en
qué orden imprimen
imprime(“g”); }
imprime(“h”);
semaforo.V();
}

qué orden imprimen
Semáforos
Existen dos tipos de semáforos:
• Semáforo binario (mutex)
• Semáforo de conteo
Semáforo binario (mutex)

Se utiliza cuando solo se tiene un recurso al cual proveer exclusión
mutua.
Semaforo mutex=new Semaforo(1);

imprime(“g”); }
imprime(“h”);
semaforo.V();
}

que orden imprimen
Proceso 1 Proceso 3
Proceso 4
Proceso 2
Proceso 5
1
Semáforo binario: el valor de S sólo puede ser 0 ó 1

Proceso1: Proceso2:
public void run(){ public void run(){
... ...
mutex.P(); ...
imprime(“a”); mutex.P();
imprime(“b”); imprime(“I”)
imprime(“c”); imprime(“II”)
imprime(“d”); imprime(“III”)
imprime(“e”); imprime(“IV”)
imprime(“f”); mutex.V();
imprime(“g”); }
imprime(“h”);
mutex.V();
}

Si se ejecutan los dos procesos al tiempo, en
qué orden imprimen
Proceso1: Proceso2:
... ...
mutex.P(); ...
cantidad=cantidad+1; mutex.P();
mutex.V(); cantidad=cantidad-5;
} mutex.V();
}

qué orden se modifica la variable cantidad
Proceso1: Proceso2:
... ...
mutex.P(); mutex.P();
cantidad=cantidad+1; cantidad=cantidad-5;
mutex.V(); mutex.V();
} }

qué orden se modifica la variable cantidad
Proceso1: Proceso2:
... ...
} }
Con un mutex se garantiza que solo uno de

los dos conjuntos de instrucciones se
ejecutan en un momento dado
Proceso1: Proceso2:
... ...
} }
La parte del código que solo puede ejecutar

un proceso al tiempo se conoce como
sección critica
public class Mesa{
1 cantidad 3
int cantidad;
public Mesa(){
cantidad=0;
}


while (cantidad<2)
}
Semáforos de conteo
Permite sincronizar el uso de n recursos por cualquier cantidad de
procesos
Semaforo semaforo=new Semaforo(n);

donde n es un número entero
imprime(“g”); }
imprime(“h”);
semaforo.V();
}

Semáforos
• Suponga que tiene tres impresoras y dos lectores de CD para
sincronizar, cuántos semáforos necesita?
Semaforo impresoras=new Semaforo(3); Semaforo lectores=new Semaforo(2);

Proceso1: Proceso2:
... ...
impresoras.P(); lectores.P();
imprime(“a”); leerDatosCD();
imprime(“b”); lectores.V();
imprime(“c”); impresoras.P();
impresoras.V(); imprime(“I”)
lectores.P(); imprime(“II”)
leerDatosCD(); imprime(“III”)
lectores.V(); imprime(“IV”)
} impresoras.V();
}
Semaforo impresoras=new Semaforo(1);

Semaforo lectores=new Semaforo(1);
Proceso1: Proceso2:
... ...
impresoras.P(); lectores.P();
lectores.P(); impresoras.P();
leerDatosCD(); leerDatosCD();
imprime(“a”); imprime(“I”)
lectores.V(); impresoras.V();
impresoras.V(); lectores.V();
} }
Semaforo impresoras=new Semaforo(1);

Semaforo lectores=new Semaforo(1);
Bloqueos mutuos (deadlock)

• Un conjunto de procesos se encuentra en bloqueo mutuo cuando
cada proceso en el conjunto está esperando un evento que solo puede
ser ocasionado por otro proceso en el conjunto
Problemas

cantidadPedidos
• El proceso Cocinero siempre coloca 1

pedido en la mesa
• El proceso Mensajero intenta tomar

2 pedidos. Si solo hay 1 ó 0 espera
hasta que por lo menos hayan dos

cantidadPedidos
atenderPedido()
Mensajero
Mensajero
atenderPedido()
Cocinero (Thread) Mensajero (Thread)
run() run()
usa usa
Mesa Programa
int cantidadPedidos usa
Mesa mesa;
colocarPedido() Cocinero c1;
atenderPedido() Mensajero m1;
main()
Semaforo Cocinero (Thread) Mensajero (Thread)

int v; Mesa mesa; Mesa mesa;
P()
run() run()
V()
usa usa usa
Mesa Programa
Mesa mesa;
atenderPedido() Mensajero m1,m2,m3;
main()
public class Mesa{
int cantidadPedidos;
public Mesa(){
cantidadPedidos=0;
}

cantidadPedidos = cantidadPedidos+1;
}

while (cantidadPedidos<2)
;
cantidadPedidos = cantidadPedidos-2;
}
}
public class Mesa{
public Mesa(){
cantidadPedidos=0;
}

}

}
}

cantidadPedidos
atenderPedido()
Mensajero
¿Qué recurso necesita un Mensajero

mensajero para completar atenderPedido()
atenderPedido()?
¿Inicialmente cuántos
recursos hay en la mesa?

cantidadPedidos
atenderPedido()
Mensajero
Mensajero
atenderPedido()
Semaforo cajasDisponibles=new Semaforo(0);


cantidadPedidos
atenderPedido()
Mensajero
¿Quién hace cajasDisponibles.P()? disminuye el semáforo

¿Quién hace cajasDisponibles.V()? aumenta el semáforo
public class Mesa{
public Mesa(){
cantidadPedidos=0;
}

}

}
}
public class Mesa{
public Mesa(){
cantidadPedidos=0;
}

}

cajasDisponibles.P();
}
}
public class Mesa{
public Mesa(){
cantidadPedidos=0;
}

}

}
}
public class Mesa{
public Mesa(){
cantidadPedidos=0;
}
¿Dónde se hace
cajasDisponibles.V()?
}

}
}
public class Mesa{
public Mesa(){
cantidadPedidos=0;
}

cajasDisponibles.V();
}

}
}
public class Mesa{
public Mesa(){
cantidadPedidos=0;
}
Suponga que quisiera
asegurar que solo un hilo al
cantidadPedidos = cantidadPedidos+1; tiempo esté modificando la
cajasDisponibles.V(); variable cantidadPedidos,
} ¿cómo lo hace?
}
}
Proceso1: Proceso2:
... ...
} }
La parte del código que solo puede ejecutar

un proceso al tiempo se conoce como
sección critica
public class Mesa{
public Mesa(){
cantidadPedidos=0;
}

}

}
}
public class Mesa{
public Mesa(){
cantidadPedidos=0;
}
mutex.P();
mutex.V();
}
mutex.P();
mutex.V();
}
}
public class Mesa{
public Mesa(){
cantidadPedidos=0;
}
Suponga que inicia el
mutex.P();
programa y el cocinero se
queda dormido, ¿dónde
mutex.V();
espera el mensajero?
}
mutex.P();
mutex.V();
}
}

cantidadPedidos
atenderPedido()
Mensajero
Mensajero
atenderPedido()
Son 3 mensajeros
Semaforo Cocinero (Thread) Mensajero (Thread)

P() int numeroMensajero;
run()
V() run()
usa usa usa
Mesa Programa
Mesa mesa;
atenderPedido() Mensajero m1,m2,m3;
main()
Problema de las naranjas

bajarNaranja() comerNaranja()
cantidadNaranjas
Reoolector 3 Comensal
bajarNaranja()
Reoolector
bajarNaranja() • Un recolector siempre baja de a una
Reoolector naranja
• El comensal come de a una naranja y
espera si no hay
Semaforo Comensal (Thread) Recolector (Thread)

int v; Canasto canasto; Canasto canasto;
P() int numeroRecolector;
run()
V() run()
usa usa usa
Canasto Programa
int cantidadNaranjas; usa
Canasto canasto;
bajarNaranja() Comensal c1;
comerNaranja() Recolector r1,r2,r3;
main()
public class Canasto{
int cantidadNaranjas;
public Canasto(){
cantidadNaranjas=0;
}
public void bajarNaranja(){
}
public void comerNaranja(){
}
}

cantidadNaranjas
bajarNaranja()
Reoolector
bajarNaranja()
Reoolector
¿Qué recurso necesita un

comensal para completar
comerNaranja()?

cantidadNaranjas
bajarNaranja()
Reoolector
bajarNaranja()
Reoolector
Semaforo naranjasDisponibles=new Semaforo(0);

cantidadNaranjas
bajarNaranja()
Reoolector
bajarNaranja()
Reoolector
¿Quién hace naranjasDisponibles.P()? disminuye el semáforo

¿Quién hace naranjasDisponibles.V()? aumenta el semáforo
public class Canasto{
int cantidadNaranjas;
public Canasto(){
cantidadNaranjas=0;
}
public void bajarNaranja(){
mutex.P();
cantidadNaranjas = cantidadNaranjas+1;
mutex.V();
naranjasDisponibles.V();
}
public void comerNaranja(){
naranjasDisponibles.P();
mutex.P();
cantidadNaranjas = cantidadNaranjas-1;
mutex.V();
}
}
Problema de los recolectores y el glotón

colocarDulce() tomarDulce()
cantidadDulces
Recolector 3 Gloton
colocarDulce()
Recolector
colocarDulce()
Recolector
• Un recolector siempre coloca 1 dulce

en la mesa
• En la mesa caben máximo 10 dulces
• El Glotón toma siempre 1 dulce, si no
hay debe esperar
Recolector (Thread) Gloton (Thread)
run() run()
usa usa
Mesa Programa
int cantidadDulces; usa
Mesa mesa;
colocarDulce() Recolector procesoRecolector;
tomarDulce() Gloton procesoGloton;
main()
Semaforo Recolector (Thread) Gloton (Thread)

P() int numeroRecolector;
run()
V() run()
usa usa usa
Mesa Programa
int cantidadDulces; usa
Mesa mesa;
colocarDulce() Recolector r1,r2,r3;
tomarDulce() Gloton g1;
main()

cantidadDulces
Recolector 3 Gloton
colocarDulce()
Recolector
colocarDulce()
Recolector

glotón para completar
tomarDulce()?

cantidadDulces
Recolector 3 Gloton
colocarDulce()
Recolector
colocarDulce()
Recolector
Semaforo dulcesDisponibles=new Semaforo(0);


cantidadDulces
Recolector 3 Gloton
colocarDulce()
Recolector
colocarDulce()
Recolector
¿Quién hace dulcesDisponibles.P()?

¿Quién hace dulcesDisponibles.V()?

cantidadDulces
Recolector 3 Gloton
colocarDulce()
Recolector
colocarDulce()
Recolector

recolector para completar
colocarDulce()?

cantidadDulces
Recolector 3 Gloton
colocarDulce()
Recolector
colocarDulce()
Recolector
Semaforo espaciosDisponibles=new Semaforo(10);


cantidadDulces
Recolector 3 Gloton
colocarDulce()
Recolector
colocarDulce()
Recolector
¿Quién hace espaciosDisponibles.P()?

¿Quién hace espaciosDisponibles.V()?
public class Mesa{
int cantidadDulces;
public Mesa(){
cantidadDulces=0;
}
public void colocarDulce(){

cantidadDulces=cantidadDulces+1;
}
public void tomarDulce(){

cantidadDulces=cantidadDulces-1;
}
}
public class Mesa{
int cantidadDulces;
public Mesa(){
cantidadDulces=0;
}

}

}
}
public class Mesa{
int cantidadDulces;
public Mesa(){
cantidadDulces=0;
}

mutex.P();
mutex.V();
}

mutex.P();
mutex.V();
}
}
public class Mesa{
int cantidadDulces;
public Mesa(){
cantidadDulces=0;
}

mutex.P();
mutex.V();
}

mutex.P();
mutex.V();
}
}
public class Mesa{
int cantidadDulces;
public Mesa(){
cantidadDulces=0;
}

mutex.P();
mutex.V();
}

dulcesDisponibles.P();
mutex.P();
mutex.V();
}
}
public class Mesa{
int cantidadDulces;
public Mesa(){
cantidadDulces=0;
}

mutex.P();
mutex.V();
dulcesDisponibles.V();
}

mutex.P();
mutex.V();
}
}
public class Mesa{
int cantidadDulces;
public Mesa(){
cantidadDulces=0;
}

mutex.P();
mutex.V();
}

mutex.P();
mutex.V();
}
}
public class Mesa{
int cantidadDulces;
public Mesa(){
cantidadDulces=0;
}
espaciosDisponibles.P();
mutex.P();
mutex.V();
}
mutex.P();
mutex.V();
}
}
public class Mesa{
int cantidadDulces;
public Mesa(){
cantidadDulces=0;
}
mutex.P();
mutex.V();
}
mutex.P();
mutex.V();
espaciosDisponibles.V();
}
}
public class Mesa{
int cantidadDulces;
public Mesa(){
cantidadDulces=0; Suponga que inicia el programa y
} los recolectores duermen, ¿dónde
public void colocarDulce(){ espera el glotón?
mutex.P();
Suponga que los recolectores
mutex.V();
colocan 10 dulces y el glotón
dulcesDisponibles.V(); duerme, si llega otro recolector
} con un dulce más, ¿dónde espera?
mutex.P();
mutex.V();
}
}
Problema de la oficina de correo

colocar() tomar()
cantidadCartas
Administrador Cartero
tomar()
Cartero
tomar()
Cartero
• Se tiene un estante con capacidad

máxima para 50 cartas
• El Administrador siempre coloca 4
cartas, espera si no caben
• Un cartero toma siempre 2 cartas,
espera si no las hay
Semaforo Administrador (Thread) Cartero (Thread)

int v; Estante estante; Estante estante;
P() int numeroCartero;
run()
V() run()
usa usa usa
Estante Programa
int cantidadCartas; usa
Estante estante;
colocar() Administrador a1;
retirar() Cartero c1,c2,c3;
main()
public class Estante{
int cantidadCartas;
public Estante(){
cantidadCartas=0;
}
public void colocar(){

cantidadCartas=cantidadCartas+4;
}
public void tomar(){

cantidadCartas=cantidadCartas-2;
}
}

colocar() tomar()
cantidadCartas
tomar()
Cartero
tomar()
Cartero

cartero para completar
tomar()?

colocar() tomar()
cantidadCartas
tomar()
Cartero
tomar()
Cartero
Semaforo cartasDisponibles=new Semaforo(0);

cartero para completar
tomar()?

colocar() tomar()
cantidadCartas
tomar()
Cartero
tomar()
Cartero

Administrador para
completar colocar()?

colocar() tomar()
cantidadCartas
tomar()
Cartero
tomar()
Cartero

Administrador para
completar colocar()?
int cantidadCartas;
public Estante(){
cantidadCartas=0;
}
}
}
}
int cantidadCartas;
public Estante(){
cantidadCartas=0;
}
mutex.P();
mutex.V();
}
mutex.P();
mutex.V();
}
}
int cantidadCartas;
public Estante(){
cantidadCartas=0;
}
mutex.P();
mutex.V();
}
mutex.P();
mutex.V();
}
}
int cantidadCartas;
public Estante(){
cantidadCartas=0;
}
mutex.P();
mutex.V();
}
cartasDisponibles.P();
mutex.P();
mutex.V();
}
}
int cantidadCartas;
public Estante(){
cantidadCartas=0;
}
mutex.P();
mutex.V();
}
mutex.P();
mutex.V();
}
int cantidadCartas;
Semaforo cartasDisponibles=new Semaforo(0), Semaforo espaciosDisponibles=new Semaforo(50
public Estante(){
cantidadCartas=0;}
mutex.P();
mutex.V();
cartasDisponibles.V();
}
mutex.P();
mutex.V();
int cantidadCartas;
Semaforo cartasDisponibles=new Semaforo(0), Semaforo espaciosDisponibles=new Semaforo(50
public Estante(){
cantidadCartas=0;}
mutex.P();
mutex.V();
}
mutex.P();
mutex.V();
mutex.P();
mutex.V();
}
mutex.P();
mutex.V();
Problema de los lectores y escritores
Cédula Salario Dirección Teléfono

1152984120 4.000.000 Calle 13 # 339 1745
100 - 00
10066044 5.800.000 Calle 25 # 336 4346
25 A 44
• Se tienen dos tipos de procesos:

- Lectores
- Escritores
Escritor Lector
BD
Lector
Lector

startRead()
Escritor Lector
BD
endRead()
startWrite()
Escritor Lector
BD
endWrite()

startRead()
Escritor Lector
BD
endRead()
startWrite() startRead()
Escritor Lector
BD
readerCount=2
Escritor Lector
BD
startRead()
Lector
readerCount=1
Escritor Lector
BD
endRead()
startRead()
Lector
startWrite()
readerCount=0
Escritor
BD
endRead()
startRead()
Lector
startWrite()
readerCount=0
Escritor
BD
startWrite()
readerCount=0
Escritor
BD
endWrite()
Escritor Lector
BD
endWrite() endRead()
• Dos hilos lectores pueden estar simultáneamente en BD

• Sin embargo, si un escritor y algún otro hilo (lector o escritor)
están en BD simultáneamente pueden ocurrir inconsistencias en
los datos

• Se debe asegurar que los escritores tengan acceso exclusivo a la
base de datos compartida
• Existen varias versiones, se trata la versión en la cual ningún lector
debe esperar a menos que un escritor ya haya obtenido permiso para
usar BD
• Esto indica que si un escritor espera y luego llega un lector, el lector
debe acceder a BD antes que el escritor
• En esta versión los escritores pueden morir de inanición posponiendo
eternamente la escritura debido a que siempre llega por los menos un
lector
Semaforo Writer (Thread) Reader (Thread)
int valor; Database database; Database database;

int numeroLector;
P() run()
V() run()
usa usa usa
Database Test
int readerCount; usa
Database database;
startRead() Writer e1;
endRead() Reader r1,r2,r3;
startWrite() main()
endWrite()
Escritor Lector
BD
endWrite() endRead()
Es una clase con los métodos:

• startWrite()
• endWrite()
• startRead()
• endRead()
que deben proveer exclusión mutua
public class Database{
int readerCount;
public Database(){
readerCount=0;
}
public void startRead(){

}
public void endRead(){

}
public void startWrite(){

}
public void endWrite(){

}
}

startRead()
Lector
endRead()
readerCount BD

startRead()
readerCount+1
Lector
readerCount endRead()
BD readerCount-1

startRead()
readerCount+1
Lector
readerCount endRead()
BD readerCount-1
startRead()
readerCount+1
Lector
endRead()
readerCount-1
public class Database{
int readerCount;
public Database(){
readerCount=0;
}

}

}
public void startWrite(){

}
public void endWrite(){

}
}
readerCount=readerCount+1;
}
readerCount=readerCount-1;
}
mutex.P();
readerCount=readerCount+1;
mutex.V();
}
mutex.P();
readerCount=readerCount-1;
mutex.V();
}

• Problema: falta controlar el acceso de los escritores de tal forma
que solamente puedan escribir cuando la cantidad de lectores sea
cero

cero
Lector
Escritor BD
• Hay un solo recurso, la BD

• Si un lector hace startRead ()
debe solicitar el recurso
• Esto solo lo hace el primer
lector

cero
Lector
Escritor BD
semaforoBD:1

cero
startRead()
Escritor Lector
BD
semaforoBD:1

cero
startRead()
Escritor Lector
readerCount (1) BD
semaforoBD:0

cero
Escritor Lector
BD
El escritor debe
esperar hasta que se
semaforoBD:0
libere el recurso

cero
startRead()
Escritor Lector
readerCount (1) BD
semaforoBD:0

cero
startRead()
Escritor Lector
startRead()
readerCount (1) BD
Lector
semaforoBD:0
¿El segundo lector

debe esperar?

cero
startRead()
Escritor Lector
startRead()
readerCount (2) BD
Lector
semaforoBD:0
El segundo lector no espera,

ya que los “lectores” tiene el
control de la base de datos

cero
startRead()
Escritor Lector
startRead()
readerCount (2) BD
Lector
semaforoBD:0
¿Cuándo retornan los

“lectores” el control de la
base de datos?

cero
startRead()
Escritor Lector
endRead()
readerCount (2) BD
startRead() Lector
semaforoBD:0

cero
Escritor
readerCount (1) BD
startRead() Lector
semaforoBD:0

cero
Escritor
startRead()
readerCount (1) BD
Lector
semaforoBD:0
endRead()

cero
Escritor
startRead()
readerCount (0) BD
Lector
semaforoBD:1
endRead()

cero
Utilizar un semáforo para controlar el acceso a la base de datos, se

hace P() en el semáforo de BD cuando un escritor quiere escribir,
será concedido solamente si el semáforo es 1, esto es, no hay
lectores. Los lectores harán V() para liberar a BD solamente cuando
hayan salido todos, es decir, readerCount es 0. Cuando un lector
ingrese a BD, es decir, haga P() y se le concede, no se retornará V()
sino hasta que salgan todos
• db es un semáforo que controla el acceso a BD
Semaforo db=new Semaforo(1);
• Inicialmente es 1
• Cada vez que se desee escribir se hace P(), también si es el primer lector
• Se hace V() cuando un escritor termina o cuando sale el ultimo de los
lectores
public void startRead(){ public void endRead(){

Solo el primero
mutex.P(); lector solicita la BD mutex.P();
readerCount=readerCount+1; readerCount=readerCount-1;
} }
lectores
Cuando se termina de leer,

public void startRead(){ public void endRead(){ se retornaría el control de
BD solamente si fuese el
mutex.P(); mutex.P(); último lector
if (readerCount==1) mutex.V();
db.P(); }
mutex.V();
}
lectores

db.P(); if (readerCount==0)
mutex.V(); db.V();
} }
lectores

mutex.V(); db.V();
} }
public void startWrite(){ public void endWrite(){
} }
lectores

mutex.V(); db.V();
} }

db.P(); db.V();
} }
Considere la siguiente situación:
Un escritor está en BD, llega un primer lector y espera en db.P(). Si llega otro lector qué ocurre?

mutex.V(); db.V();
} }

db.P(); db.V();
} }
Considere la siguiente situación:
Un escritor está en BD, llega un primer lector y espera en db.P(). Si llega otro lector qué ocurre:
• Empieza a leer porque no cumple la condición de readerCount==1 y supone que está leyendo ó,
• ¿Dónde dice que espere?

mutex.V(); db.V();
} }

db.P(); db.V();
} }

Clase Sincronizacion

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Clase Sincronizacion

Cargado por

Copyright:

Formatos disponibles

Sistemas Operativos

• Suponga un archivo cuyos registros están compuestos de los

Cédula Salario Dirección Teléfono

• Se tienen dos tipos de procesos:

• Los problemas se presentan cuando los procesos obtienen acceso a

Problema del restaurante Chino

Cocinero (Thread) Mensajero (Thread)

Mesa mesa; Mesa mesa;

public void colocarPedido(){

public void atenderPedido(){

public void colocarPedido(){

public void atenderPedido(){

public void colocarPedido(){

public void atenderPedido(){

public void colocarPedido(){ register1=cantidad

public void atenderPedido(){

Si TODAS las instrucciones se

r1=0 r2=3 c=3

r1=0 r2=3 c=3

register2=register2-2 r1=3 r2=1 c=3

public void colocarPedido(){ register1=cantidad

public void atenderPedido(){

public void colocarPedido(){

public void atenderPedido(){ Acá se presenta espera activa,

Problema del restaurante Chino

Valor actual del

Un semáforo es una variable entera que tiene dos operaciones:

- P(). Permite pedir un recurso. Disminuye en 1 el valor del semáforo

- V(). Permite indicar que hay un recurso más disponible. Aumenta

public void P(){

public void V(){

Semaforo semaforo1=new Semaforo(3);

Semaforo semaforo1=new Semaforo(3);

semaforo1.P(): si hay un recurso disponible se concede y se

Proceso 1 Recurso Proceso 3

Proceso 1 Recurso Proceso 3

semaforo1.V(): indica que hay un recurso más disponible. El

Semaforo semaforo=new Semaforo(2);

Semaforo semaforo=new Semaforo(2);

Semaforo semaforo=new Semaforo(1);

Semáforo binario (mutex)

Semaforo mutex=new Semaforo(1);

Semaforo semaforo=new Semaforo(1);

Semáforo binario: el valor de S sólo puede ser 0 ó 1

Semaforo mutex=new Semaforo(1);

Semaforo mutex=new Semaforo(1);

Semaforo mutex=new Semaforo(1);

Con un mutex se garantiza que solo uno de

La parte del código que solo puede ejecutar

public void colocarPedido(){ register1=cantidad

public void atenderPedido(){

Semaforo semaforo=new Semaforo(n);

Semaforo semaforo=new Semaforo(2);

Semaforo impresoras=new Semaforo(3); Semaforo lectores=new Semaforo(2);

Semaforo impresoras=new Semaforo(1);

Semaforo impresoras=new Semaforo(1);

Bloqueos mutuos (deadlock)

Problema del restaurante Chino

• El proceso Cocinero siempre coloca 1

• El proceso Mensajero intenta tomar

Problema del restaurante Chino

Cocinero (Thread) Mensajero (Thread)

Mesa mesa; Mesa mesa;