Semáforos

Son una herramienta de sincronización. Es una variable protegida que solo puede ser modificada por la rutina de inicialización y por otras dos operaciones atómicas:

P( ) <- wait

V( ) <- signal

Las operaciones a las cuales se puede acceder son:

Inicialización: Crea un nuevo semáforo asignándole un valor inicial

P(s): while (s=0) do no_op ATÓMICA

s:=s-1

V(s): s:=s+1 ATÓMICA

Existen básicamente dos tipos de semáforos:

* Semáforos contadores: Toman valores positivos mayores o iguales a 0. Se utilizan para sincronización de procesos.

* Semáforos binarios: Toman los valores 0 ó 1 y se utilizan para exclusión mutua.

A continuación se presenta una solución mediante semáforos del problema productor/consumidor.

#define N 100

semaphore mutex = 1;

semaphore empty = N;

semaphore full = 0;

void productor(void)

{int item;

while(1){

produce_item(item);

down(empty);

down(mutex);

enter_item(item);

up(mutex);

up(full);}

}

void consumidor(void)

{ int item;

while(1){

down(full);

down(mutex);

remove_item(&item);

up(mutex);

up(empty);

consume_item(item);}

}

En este caso tenemos la utilización de 3 semáforos, uno destinado al control de la exclusión mutua y los otros dos destinados a la sincronización de los procesos para el control de buffer lleno y vacío.

Podríamos utilizar semáforos para un algoritmo de espera ocupada con n procesos, pero los n procesos que están ejecutando el while de la función P(s) van a la cola de ready en un instante de tiempo reduciendo la performance general del equipo.

Para evitar la espera ocupada se crea un semáforo que sea un registro de un nuevo tipo:

Semáforo = Record

Valor:Integer

L:Lista_de_Procesos

End

P(s) {

s.Valor:= s.valor - 1

if s.Valor <>

bloquear;

end}

V(s){

s.Valor:=s.Valor + 1

if s.Valor £ 0 then quitar un proceso y a s.L

Despertar (y) }