MECANISMOS DE

SINCRONIZACIN

 Los procesos que ejecutan de forma Concurrente en un

sistema
se
pueden
clasificar
como
procesos
independientes o cooperantes.
Un proceso independiente es aquel que Ejecuta sin
requerir la ayuda o cooperacin de otros procesos.
Los procesos son cooperantes cuando estn diseados
para trabajar conjuntamente en alguna actividad, para lo
que deben ser capaces de comunicarse e interactuar
entre ellos.

Mecanismos de Comunicacin en
Programacin Concurrente
Los

mecanismos de sincronizacin permiten la

comunicacin entre los procesos o hilos, basados en
memoria compartida utilizando la semntica de acceso a
memoria compartida, tales como son:
Semforos
Monitores
Mutex y Variables condicionales
Candados
Paso de Mensajes
Canales

Las operaciones de sincronizacin deben ser atmicas.

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 travs de
ella es una va habitual de comunicacin y sincronizacin
entre ellos.

Tipos de mecanismo

Semforos: Son componentes pasivos de bajo nivel de

abstraccin que sirven para arbitrar el acceso a un recurso
compartido. (Dijkstra, 1968).
Secciones crticas: Son mecanismos de nivel medio de
abstraccin orientados a su implementacin en el contexto
de un lenguaje concurrente y que permiten la ejecucin de
un bloque de sentencias de forma segura. Tienen un nivel
de abstraccin mucho mas alto que los semforos, y en
consecuencia son ms fciles y seguros de manejar.
(Brinch Hansen, 1972).
Monitores: Son mdulos de alto nivel de abstraccin
orientados a la gestin de recursos que van a ser usados
concurrentemente. Resuelven internamente, el acceso de
forma segura a una variable o a un recurso compartido por
mltiples procesos concurrentes. Hoare,1974.

Estructura general de un Mecanismo de

Sincronizacin
La estructura general, por tanto, de cualquier mecanismo

que pretenda resolver el problema de la seccin crtica es

la siguiente:

Entrada en la seccin crtica

Cdigo de la seccin
crtica
Salida de la seccin crtica

Desventajas Algoritmos de E. Mutua

Los

Algoritmos de E. Mutua presentan varios

inconvenientes:
y Utilizan espera ocupada
y Requieren un anlisis y programacin muy cuidados
y Estn muy ligados a la mquina en que se
implementan
y No son transportables
y No dan una interfaz directa al programador
y Son poco estructurados
y Son difciles de extender a un nmero arbitrario de
entidades concurrentes

SEMFOROS

Semforos: Definicin y operaciones

y Definicin: Un semforo es una variable S entera que toma

valores no negativos y sobre la que se pueden realizar dos

operaciones. Son introducidos inicialmente por Djisktra.
y Es una estructura de datos abstracta que nos permiten el
manejo de una regin crtica.
y

Operaciones soportadas:
(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.
Wait

Notacin:
Wait (S)=P(S)
Init(S,
inical al Signal (S)=V(S)
semaforo

valor).
Da
contador

valor
del

10

Generalidades
Wait y Signal son atmicas
El valor inicial de un semforo es no negativo
Signal despierta a algn proceso suspendido por

el semaforo, no especificado por la definicin

Hiptesis de correccin
Semforos generales: S=>0
Semforos binarios: S=0, 1
Ecuaciones
de
Invariancia:
deben
ser
satisfechas por cualquier implementacin:

11

Implemetacin Semforos
Contador-integer
Cola-lista

1. La variable S mantiene el valor actual del semforo.

2. L es una estructura de datos, en principio dinmica.
3. Cuando S = 0 y un proceso llama a Wait es bloqueado y
mantenido en la lista S
4. Cuando otro proceso sealiza sobre S, algunos de los
bloqueados sale de L segn algn algoritmo de prioridad

Tipos de Semforos
Semforos binarios: Pueden tomar solo los valores 0 y 1.
Semforos general: Puede tomar cualquier valor Natural

(entero no negativo).

Semforo General
Un semforo 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).

Semforos y POO
En trminos de la orientacin a objetos un semforo S se crea

a partir de una clase que tiene un atributo privado de tipo

nmero entero y una pareja de mtodos pblicos P y V.
El funcionamiento de tales operaciones sobre S se define a
continuacin:
Si el valor del contador S es positivo, un hilo al invocar P(S)

decrementa a S en una accin atmica; 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
semforo entonces el valor del contador S se incrementa
atmicamente; de otra forma uno de los hilos en espera se libera y se
le permite continuar ejecutando su cdigo en las siguientes
instrucciones de donde fue interrumpido (i.e. inmediatamente despus
de P(S)
Las operaciones sobre el contador del semforo deben

realizarse atmicamente para evitar condiciones de contencin

Semforo Binario
Un semforo binario slo puede tener valores de su

contador entre 0 y 1.
Cuando es iniciado con valor 1 permite resolver el
problema de la exclusin mutua:

Semforo binario compartido mutex con valor inicial 1

en cada hilo:
P(mutex); //preprotocolo
Seccin crtica
V(mutex); //postprotocolo

Ventaja de los Semforos Binarios

Por tanto, los semforos binarios sirven para dos

propsitos:
Sincronizacin de exclusin mutua
Condicin de sincronizacin: bloquear a los hilos hasta que alguna

condicin se haga verdadera u ocurra un evento:

Semforo 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; //semforos binrios 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 recurso
{
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();
}}

Cmo funcionan los semforos?

y La operacin inicializa se debe llevar a cabo antes de

que comience la ejecucin concurrente de los

procesos ya que su funcin exclusiva es dar un valor
inicial al semforo.
y Un proceso que corre la operacin espera y encuentra
el semforo a 1, lo pone a 0 y prosigue su ejecucin.
Si el semforo est a 0 el proceso queda en estado de
espera hasta que el semforo se libera.

Estados del Proceso y semforos

y Un proceso en espera de un semforo no est en

ejecucin, 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 semforo.
y Tampoco es vlido 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 conexin con
los semforos.

Transiciones de el estado de EsperaWait()

y Cuando se ejecuta la operacin seal puede haber varios

procesos en la lista o cola, el proceso que la dejar para pasar al

estado listo depender del esquema de gestin de la cola de
tareas suspendidas que se haya implementado en el diseo del
semforo, por ejemplo: FIFO, etc.
y Si no hay ningn proceso en espera del semforo este se deja libre
(S := 1) para el primero que lo requiera.
Ejecucin
Espera

Seal
Listo

Suspendido

Dormido

Figura 1. Transiciones para el estado de espera

Exclusin Mutua con Semforos

y La exclusin mutua se realiza fcilmente utilizando

semforos.
y La operacin de espera (wait) se usar como
procedimiento de bloqueo antes de acceder a una
seccin crtica y la operacin seal(signal) como
procedimiento de desbloqueo.
y Se utilizarn tantos semforos como clases de
secciones crticas se establezcan.
P1

wait (S) ;
Seccin Crtica
signal (S) ;

P2

wait (S) ;
Seccin Crtica
signal (S) ;

Sincronizacin con Semforos

y El

uso de semforos hace que se pueda programar

fcilmente la sincronizacin entre dos tareas.
y En este caso las operaciones espera y seal no se utilizan
dentro de un mismo proceso sino que se dan en dos
procesos separados. El que ejecuta la operacin de espera
queda bloqueado hasta que el otro proceso ejecuta la
operacin de seal.
y A veces se emplea la palabra seal para denominar un

semforo que se usa para sincronizar procesos. En este

caso una seal tiene dos operaciones: espera y seal que
utilizan para sincronizarse dos procesos distintos.
y 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 semforos
(* Sincronizacin con semforo*)
Procesos con semaforos
Mtodo de Sincronizacin;
var S: semaforo;
P1 (* Proceso que espera *)
Inicio_P1
wait(S);
....
Fin_P1
P2 (* Proceso que seala *)
Inicio_P1
....
signal(S);
....
Fin_P2;

Sincronizacin con semforo

Inicia_Sincronizacin
//Inicializa el semforo
S= 0;
P1(S)
P2(S)
Fin_Sincronizacin

Qu Proceso espera?
Qu Proceso Inicia?

Cmo se realiza la sincronizacin

usando los semforos?
y El semforo=0 de modo que cuando el proceso P1

ejecuta la operacin de espera se suspende hasta que

el proceso P2 ejecuta la operacin seal.
y La sincronizacin se realiza perfectamente incluso si el

proceso P2 ejecuta la operacin seal antes de que el

proceso P1 ejecute la operacin de espera, ya que en
este caso el proceso P2 incrementa el semforo y
permite que P1 decremente el semforo y siga su
ejecucin cuando alcanza la operacin espera.

Semforos en Java
Los semforos 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 semforos como parte de los llamados al sistema
para comunicacin interprocesos (IPC)).
Los semforos binarios o contadores no se encuentran
disponibles como tales en Java, pero su construccin no
es difcil ya que Java ofrece como mecanismo para
sincronizacin entre hilos a los monitores (que se vern
en la siguiente seccin).
Los semforos utilizados para asegurar exclusin mutua
son iniciados a 1 y slo toman 2 valores: 1 indica cuando
la SC se encuentra libre y 0 cuando est siendo ocupada.

Semforos 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).
Adems de asegurar exclusin mutua (solo se permite que un
hilo se apodere de un candado a la vez), tambin se puede
utilizar a un semforo binario para comunicacin entre hilos, al
bloquear a un hilo hasta que ocurra un evento que ser
causado por otro hilo.
Semforo 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 seal o V()

public synchronized void SIGNAL()
{
count++;
notify();
}
}

EJEMPLO DE HOLA
MUNDO

Cmo funciona el semforo?

Recurso Compartido
Impresin del Mensaje
Cuntos semforos se necesita ?
Un solo semforo de acuerdo al nmero de recursos compartidos
Que realiza el semforo?
Establece el mecanismo de acceso al recurso compartido (exlusin
mutua) por parte de dos hilos que tienen que enviar su mensaje

Establecer el semforo
Pre-Protocolo
Semaphoro(S).WAIT
Seccin 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();
}
}

Sincronizacin con Semforos

Los semforos tambin se pueden utilizar en la sincronizacin de procesos.
Consideremos los procesos P1 y P2 y que P2 no puede ejecutar d hasta que

P1 no haya finalizado la ejecucin de a.

P1 :
begin

P2 :
begin
a;
b;

c;
d;

end

end

Se puede resolver el problema utilizando un semforo, 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 especificacin del problema puede determinar el

nmero de primitivas de semforo y su ubicacin.

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 semforo, 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 ms rpido, P2 podra ejecutar d sin que P3

hubiera ejecutado e.
La solucin correcta es utilizar dos semforos, 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

Semforos de sincronizacin
Un

semforo permite estableces grafos de precedencia.

Asociaremos a cada rama un semforo. 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
estn 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 sincronizacin.
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

semforos y se muestra el uso de los semforos.

VAR a,b,c,d: semaphore
BEGIN
COBEGIN
BEGIN

S1;
signal (a);
signal (b);

P1
END;

BEGIN

P2

wait(a);
S2;
signal(c);
END;

P3

P4

BEGIN

wait(b);
S3;
signal(d);
END;
BEGIN

wait(c);
wait(d);
S4;
END;

COEND;
END;

 Los semforos de paso se inicializan siempre a cero de

modo que se respete el orden de precedencia

Semforos 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: Semforos Binarios Mutex

P1, imprime A, pero espera a que primero se imprima

una B
P2, imprime B, despus 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) Disee el grafo
b) Elabore la solucin con semforos 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
semforos.
(ejemplo anterior)
Realizar el programa en
Java que permita enviar
los mensajes de cada
proceso segn entren a la
seccin critica mandando
el mensaje soy el proceso
#1 y la instruccin s#
utilizando
semforos.
(crear el semforo)

Grafo

Programa en Java

Actividad de Auto-aprendizaje
y Supongamos que tenemos 4 procesos (p1, p2, p3, p4), cada

proceso realiza su tarea de forma simultneamente (durante un

tiempo indefinido) y posteriormente termina.
y Supongamos adems que necesitamos que se ejecuten primero los
procesos P1 y P3, y luego P2 y P4.
y Realizar el programa que muestre la ejecucin de estos procesos
con semforos y contesta las preguntas.

P1

P3
Grafo de procedencia

P2

P4

Preguntas a resolver
1. Qu problemtica se resolvi a utilizar los

semforos?
2. Cuntos semforos se ocuparon, por qu?
3. Explica con tus propias palabras, la funcin
del semforo

52

Ejemplos
1. Supongamos que existen 4 montones de

papel. Hay que tomar un papel de cada montn

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 montn completo.

53

En Grapar
Proceso 1: Amontonar
Var S:semaforo
Mesa: tipo L
Proceso Amontonar
Repetir
toma 1 hoja de cada montn
regin mesa hacer
deja el grupo de 4 hojas en la mesa

fin_regin
Signal (s)
Hasta que se acaban las hojas

Proceso 2: Grapar
Proceso Grapar
repetir
Wait(s)
regin mesa hacer
toma un grupo de la mesa y
otro de la grapa

fin_regin

hasta que no queden montones

por grapar

54

Problemas Clsicos a Resolver en Equipo

1. Realizar los

programas
concurrentes
utilizando las
primitivas de Java
para sincronizar los
procesos.
2. Realizar los
programas
concurrentes
utilizando semforos
para sincronizar los
procesos.

Programa Grapar
Programa Bao
Programa del Puente
Programa Camiones
Programa de Tribu o
Canbales
6. Lectores y escritores
7. Filsofos Comensales
8. Productor Consumidor
9. Barbero Dormiln
10. Estacionamiento.
1.
2.
3.
4.
5.

Fecha: 4/octubre/2012