Ejemplo

El problema del Productor Consumidor

Considrese el problema del
productor y el consumidor (o
problema del buffer limitado).
Dos procesos comparten un buffer, el
productor coloca informacin en el
buffer y el consumidor, la extrae.

Codigo con problemas:

Codigo con problemas:

#define N 100 /* nmero de ranuras en el buffer */
Int cout = 0; /* nmero de elementos en el buffer */
producer()
{
while (TRUE){ /* repetir indefinidamente */
produe_item(); /* generar el siguiente elemento */
if (count == N) sleep();/* si el buffer est lleno, bloquearse */
enter_item(); /* colocar un elemento en el buffer */
count = count + 1; /* incrementar conteo de elementos */
if (count == 1) wakeup(consumer); /* estaba vaco el buffer? */
}
}

consumer()
{
while (TRUE){ /* repetir indefinidamente */
if (count == 0) sleep(); /* si el buffer est vaco, bloquearse */
remove_item(); /* sacar el elemento del buffer */
count = count - 1; /* disminuir conteo de elementos */
if (count == N - 1) wakeup(producer); /* estaba lleno el buffer? */
consume_item(); /* imprimir el elemento */
}
}

Qu es un semforo?
Qu es un semforo?
Unsemforoes una variable entera que cuenta el
nmero de desbloqueos guardados para uso futuro.
Las operaciones para manejo de semforos son
down y up. La operacin down verifica un semforo
y si es mayor que 0 lo decrementa (es decir, utiliza
el desbloqueo almacenado) sino el procesos se
bloquea. La operacin up incrementa un semforo.
Si hay ms de un proceso bloqueado por ese
semforo, se elige uno al azar para desbloquearlo,
por tanto el semforo seguir siendo 0 pero habr
un proceso menos bloqueado en l.

Implantacin de semforos

#define N 100 /* nmero de ranuras en el

buffer */
typedef int semaphore; /* los semforos son un
tipo especial de int */
semaphore mutex = 1; /* controla el acceso a
la regin crtica */
semaphore empty = N; /* cuenta ranuras
vacas */
semaphore full = 0; /* cuenta ranuras
completas */

Solucin del problema :

Codigo
producer()
{
int item;
while (TRUE){ /* repetir indefinidamente */
produce_item(&item); /* generar el siguiente elemento */
down(empty); /* disminuir el conteo vaco */
down(mutex); /* entrar en regin crtica */
enter_item(); /* colocar un elemento en el buffer */
up(mutex); /* salir de la regin crtica */
up(full); /* incrementar ranuras completas */
}
}

consumer()
{
int item;
while (TRUE){ /* repetir indefinidamente */
produce_item(&item); /* generar el siguiente elemento */
down(full); /* disminuir el conteo completo */
down(mutex); /* entrar en regin crtica */
remove_item(); /* tomad un elemento del buffer */
up(mutex); /* salir de la regin crtica */
up(empty); /* incrementar ranuras vacas */
consume_item(); /* hacer algo con el elemento */
}
}