Semáforo (informática)

Un semáforo es una variable especial protegida (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 y se usaron por primera vez en el sistema operativo THEOS.

Operaciones

Los semáforos sólo pueden ser manipulados usando las siguientes operaciones (este 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 por qué de los nombres de estas funciones, V y P, tienen su origen en el idioma holandé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" con los valores 0 y 1).

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.

Usos

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 puede despertar y seguir ejecutando.

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. Éste 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 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 semaforo s; /* declaración de la variable semáforo de valor entero*/
   Inicia (s,1)   /* Inicializa un semáforo con 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