Semáforo (informática)

Un semáforo es una variable especial (o tipo abstracto de datos) que constituye el método clásico para restringir o permitir el acceso a recursos compartidos (por ejemplo, un recurso de almacenamiento del sistema o variables del código fuente) en un entorno de multiprocesamiento (en el que se ejecutarán varios procesos concurrentemente). Fueron inventados por Edsger Dijkstra en 1965 y se usaron por primera vez en el sistema operativo THEOS^{[cita requerida]}.

Analogía de la biblioteca

Suponga que una biblioteca tiene 10 salas de estudio idénticas, para ser utilizadas por un estudiante a la vez. Los estudiantes deben solicitar una habitación en la recepción si desean usar una sala de estudio. Si no hay habitaciones libres, los estudiantes esperan en el mostrador hasta que alguien ceda una habitación. Cuando un estudiante ha terminado de usar una habitación, el estudiante debe regresar al mostrador e indicar que una habitación está libre.

En la implementación más simple, el empleado de recepción solo conoce la cantidad de habitaciones libres disponibles, que solo saben correctamente si todos los estudiantes realmente usan su habitación mientras se hayan registrado y las devuelvan cuando terminen. Cuando un estudiante solicita una habitación, el recepcionista disminuye este número. Cuando un estudiante libera una habitación, el recepcionista aumenta este número. La habitación se puede utilizar durante el tiempo que se desee, por lo que no es posible reservar habitaciones con antelación.

En este escenario, el contador de la recepción representa un semáforo de conteo, las habitaciones son el recurso y los estudiantes representan procesos/hilos. El valor del semáforo en este escenario es inicialmente 10, con todas las habitaciones vacías. Cuando un estudiante solicita una habitación, se le concede acceso y el valor del semáforo se cambia a 9. Después de que llegue el siguiente estudiante, se reduce a 8, luego a 7 y así sucesivamente. Si alguien solicita una habitación y el valor actual del semáforo es 0,​ se ve obligado a esperar hasta que se libere una habitación (cuando el recuento aumenta de 0). Si se liberó una de las salas, pero hay varios estudiantes esperando, entonces se puede usar cualquier método para seleccionar quién ocupará la sala (como FIFO o lanzar una moneda). Y, por supuesto, un estudiante debe informar al recepcionista sobre la liberación de su habitación solo después de dejarla realmente; de lo contrario, puede haber una situación incómoda cuando dicho estudiante está en el proceso de abandonar la habitación (está guardando sus libros de texto, etc.) y otro estudiante entra en la habitación antes de que salga.

Operaciones

Los semáforos sólo pueden ser manipulados usando las siguientes operaciones (éste es el código con espera activa):

Inicia(Semáforo s, Entero v)
{
  s = v;
}

En el que se iniciará la variable semáforo s a un valor entero v.

P(Semáforo s)
{
  if(s>0)  
      s = s-1;  
  else
      wait();
}

La cual mantendrá en espera activa al regido por el semáforo si este tiene un valor inferior o igual al nulo.

V(Semáforo s)
{
   if(!procesos_bloqueados)
        s = s+1;  
   else
        signal(); 
}

Estas instrucciones pueden modificarse para evitar la espera activa, haciendo que la operación P duerma al mismo proceso que la ejecuta si no puede decrementar el valor, mientras que la operación V despierta a un proceso que no es quien la ejecuta. En un pseudolenguaje más entendible, la operación P suele denominarse "wait" o "espera" y la operación V "signal" o "señal".

El porqué de los nombres de estas funciones, V y P, tiene su origen en el idioma neerlandés. "Verhogen" significa incrementar y "Proberen" probar, aunque Dijkstra usó la palabra inventada prolaag [1], que es una combinación de probeer te verlagen (intentar decrementar). El valor del semáforo es el número de unidades del recurso que están disponibles (si sólo hay un recurso, se utiliza un "semáforo binario" cuyo valor inicial es 1).

La verificación y modificación del valor, así como la posibilidad de irse a dormir (bloquearse) se realiza en conjunto, como una sola e indivisible acción atómica. El sistema operativo garantiza que al iniciar una operación con un semáforo, ningún otro proceso puede tener acceso al semáforo hasta que la operación termine o se bloquee. Esta atomicidad es absolutamente esencial para resolver los problemas de sincronización y evitar condiciones de competencia.

Si hay n recursos, se inicializará el semáforo al número n. Así, cada proceso, al ir solicitando un recurso, verificará que el valor del semáforo sea mayor de 0; si es así es que existen recursos libres, seguidamente acaparará el recurso y decrementará el valor del semáforo.

Cuando el semáforo alcance el valor 0, significará que todos los recursos están siendo utilizados, y los procesos que quieran solicitar un recurso deberán esperar a que el semáforo sea positivo, esto es: alguno de los procesos que están usando los recursos habrá terminado con él e incrementará el semáforo con un signal o V(s).

Inicia se utiliza para inicializar el semáforo antes de que se hagan peticiones sobre él, y toma por argumento a un entero. La operación P cuando no hay un recurso disponible, detiene la ejecución quedando en espera activa (o durmiendo) hasta que el valor del semáforo sea positivo, en cuyo caso lo reclama inmediatamente decrementándolo. V es la operación inversa: hace disponible un recurso después de que el proceso ha terminado de usarlo. Las operaciones P y V han de ser indivisibles (o atómicas), lo que quiere decir que cada una de las operaciones no debe ser interrumpida en medio de su ejecución.

La operación V es denominada a veces subir el semáforo (up) y la operación P se conoce también como bajar el semáforo (down), y también son llamadas signal y wait o soltar y tomar.

Para evitar la espera activa, un semáforo puede tener asociada una cola de procesos (normalmente una cola FIFO). Si un proceso efectúa una operación P en un semáforo que tiene valor cero, el proceso es detenido y añadido a la cola del semáforo. Cuando otro proceso incrementa el semáforo mediante la operación V y hay procesos en la cola asociada, se extrae uno de ellos (el primero que entró en una cola FIFO) y se reanuda su ejecución.

Aplicaciones

Los semáforos se emplean para permitir el acceso a diferentes partes de programas (llamados secciones críticas) donde se manipulan variables o recursos que deben ser accedidos de forma especial. Según el valor con que son inicializados se permiten a más o menos procesos utilizar el recurso de forma simultánea.

Un tipo simple de semáforo es el binario, que puede tomar solamente los valores 0 y 1. Se inicializan en 1 y son usados cuando sólo un proceso puede acceder a un recurso a la vez. Son esencialmente lo mismo que los mutex. Cuando el recurso está disponible, un proceso accede y decrementa el valor del semáforo con la operación P. El valor queda entonces en 0, lo que hace que si otro proceso intenta decrementarlo tenga que esperar. Cuando el proceso que decrementó el semáforo realiza una operación V, algún proceso que estaba esperando comienza a utilizar el recurso.

Para hacer que dos procesos se ejecuten en una secuencia predeterminada puede usarse un semáforo inicializado en 0. El proceso que debe ejecutar primero en la secuencia realiza la operación V sobre el semáforo antes del código que debe ser ejecutado después del otro proceso. Este ejecuta la operación P. Si el segundo proceso en la secuencia es programado para ejecutar antes que el otro, al hacer P dormirá hasta que el primer proceso de la secuencia pase por su operación V. Este modo de uso se denomina señalación (signaling), y se usa para que un proceso o hilo de ejecución le haga saber a otro que algo ha sucedido.

Ejemplo de uso

Los semáforos pueden ser usados para diferentes propósitos, entre ellos:

• Implementar cierres de exclusión mutua o locks
• Barreras
• Permitir a un máximo de N threads (hilos) acceder a un recurso, inicializando el semáforo en N
• Notificación. Inicializando el semáforo en 0 puede usarse para comunicación entre threads sobre la disponibilidad de un recurso

En el siguiente ejemplo se crean y ejecutan n procesos que intentarán entrar en su sección crítica cada vez que puedan, y lo lograrán siempre de a uno por vez, gracias al uso del semáforo s inicializado en 1. El mismo tiene la misma función que un lock.

const int n    /* número de procesos */
variable semáforo s; /* declaración de la variable semáforo de valor entero*/
Inicia (s,1)   /* Inicializa un semáforo de nombre s con valor 1 */

void P (int i) {
  while (cierto) {
    P(s)    * En semáforos binarios, lo correcto es poner un P(s) antes de entrar en 
              la sección crítica, para restringir el uso de esta región del código */
           /* SECCIÓN CRÍTICA */
    V(s)   /* Tras la sección crítica, volvemos a poner el semáforo a 1 para que otro
               proceso pueda usarla */
           /* RESTO DEL CÓDIGO */
  }
}

int main() {
  Comenzar-procesos(P(1), P(2),...,P(n));
}

Véase también

• El problema del barbero durmiente
• El problema de los filósofos
• Cierre de exclusión mutua
• Monitor (concurrencia)

Enlaces externos

• The Little Book of Semaphores by Allen B. Downey
• Semáforos en C para linux

• Datos: Q221682