CodeGym /Cursos /C# SELF /Semanforos: Semaphore y SemaphoreSlim

Semanforos: Semaphore y SemaphoreSlim

C# SELF
Nivel 56, Lección 3
Disponible

1. Introducción

Mutex y lock son como un barista que atiende a un cliente a la vez. ¿Pero qué pasa si no tienes una sola cafetera, sino tres — y se pueden preparar tres cafés al mismo tiempo?

Por ejemplo, tienes una cafetería con tres máquinas de café. Los clientes (hilos) llegan, ocupan una máquina libre, hacen el café y se van. Si las tres máquinas están ocupadas, los demás esperan hasta que se libere alguna.

Pregunta: ¿Cómo hacer para que no trabajen más de tres clientes a la vez en las máquinas, y los demás esperen su turno?
Respuesta: ¡usar un semaforo!

¿Qué es un semáforo?

El semáforo es una herramienta clásica de sincronización. Si lock/Mutex controlan "uno entra — los demás esperan", el semáforo dice: "¡permito N simultáneamente!".

Los semáforos fueron propuestos por Edsger Dijkstra en 1965. El nombre viene de la señalización marítima: como las banderas transmitían información disponible, el semáforo en el código indica a los hilos — pueden entrar o deben esperar.

Escenarios de uso

  • Limitar el número de hilos que acceden al mismo recurso simultáneamente.
  • Límite de conexiones simultáneas a la BD, número de requests en paralelo, tareas pesadas.

2. Resumen de clases: Semaphore y SemaphoreSlim

Semaphore

  • Clase pesada, usa objetos del kernel del SO (kernel objects).
  • Soporta sincronización entre hilos de procesos distintos.
  • Se le puede dar un nombre y compartir entre procesos.

SemaphoreSlim

  • Versión ligera, funciona solo dentro de un mismo proceso.
  • Más rápida y eficiente en recursos.
  • Casi siempre preferible si no necesitas sincronización entre procesos.

Analogía: mochila de viaje (SemaphoreSlim) frente a maleta grande (Semaphore). Si viajas ligero — lleva la mochila.

Tabla comparativa

Clase Interprocesos Rendimiento Recomendado
Semaphore
Sí Más lento Cuando se necesita sincronización entre procesos
SemaphoreSlim
No Más rápido En el 99% de los casos, dentro de un solo proceso

Métodos y propiedades principales del semáforo

Parámetros principales

  • InitialCount — número inicial de permisos.
  • MaxCount — máximo de permisos otorgados simultáneamente.

Métodos clave

  • Wait() o WaitAsync() — solicitar acceso (tomar un permiso).
  • Release() — liberar un permiso.

Cómo funciona
Si al llamar a Wait() no hay permisos, el hilo se bloquea y espera hasta que alguien llame a Release(). Tras liberarse, uno de los que esperan continuará.

3. Primer ejemplo práctico

Añadamos a una aplicación de consola un "parking" con 3 plazas e intentemos arrancar 10 hilos.

using System;
using System.Threading;

class Program
{
    // Semáforo con 3 permisos (3 plazas de parking)
    static SemaphoreSlim parking = new SemaphoreSlim(3);

    static void Main()
    {
        for (int i = 1; i <= 10; i++)
        {
            int carNumber = i;
            new Thread(() =>
            {
                Console.WriteLine($"Coche #{carNumber} intenta aparcar...");
                parking.Wait(); // Espera una plaza libre
                Console.WriteLine($"Coche #{carNumber} ha aparcado!");
                Thread.Sleep(2000); // Estancia en el parking 2 segundos
                Console.WriteLine($"Coche #{carNumber} sale del parking.");
                parking.Release(); // Liberamos la plaza
            }).Start();
        }
    }
}
  • Sólo tres coches "aparcados" simultáneamente.
  • Los demás esperarán a que se libere una plaza.
  • La salida se mezcla — esto es normal en multihilo.

4. Semáforo como limitador de carga

Limitemos el número de tareas pesadas simultáneas (por ejemplo, descargas) a 5.

static SemaphoreSlim semaphore = new SemaphoreSlim(5); // máximo 5 descargas simultáneas

static void DownloadFile(int fileId)
{
    semaphore.Wait();
    try
    {
        Console.WriteLine($"--> Empiezo a descargar el fichero {fileId}");
        Thread.Sleep(1000 + fileId * 100); // Descargando (simulación)
        Console.WriteLine($"<-- Fichero {fileId} descargado");
    }
    finally
    {
        semaphore.Release();
    }
}

static void Main()
{
    for (int i = 1; i <= 12; i++)
    {
        int localId = i;
        new Thread(() => DownloadFile(localId)).Start();
    }
}

Punto importante: coloca Wait() antes del bloque try, y Release() en el finally. Así el permiso se liberará incluso si ocurre una excepción.

5. Wait(int millisecondsTimeout) y métodos asíncronos

Puedes esperar solo un tiempo limitado:

if (semaphore.Wait(500))
{
    // ¡Conseguimos tomar el permiso en medio segundo!
}
else
{
    // No esperó 500 ms — abortamos
}

En aplicaciones modernas (por ejemplo, ASP.NET) usa la variante asíncrona: await semaphore.WaitAsync(). Esto no bloquea el hilo mientras se espera el permiso.
Nota: en código asíncrono usa SemaphoreSlim y su WaitAsync, de lo contrario puedes obtener deadlocks inesperados.

6. Ejemplos de mal y buen uso

Error común — olvidar llamar a Release(): los permisos "se fugan" y todo se paraliza.

Mal

static void SomeWork()
{
    semaphore.Wait();
    // ... procesamiento, ¡y olvidaron Release!
}

Bien

static void SomeWork()
{
    semaphore.Wait();
    try
    {
        // procesamiento
    }
    finally
    {
        semaphore.Release();
    }
}

Variante asíncrona

static async Task SomeAsyncWork()
{
    await semaphore.WaitAsync();
    try
    {
        // procesamiento asíncrono
    }
    finally
    {
        semaphore.Release();
    }
}

7. Estructura interna del semáforo (explicación "a grandes rasgos")

El semáforo es un contador. Wait() lo decrementa en 1. Si era > 0 — el hilo pasa; si es 0 — el hilo espera. Release() incrementa el contador y despierta a los que esperan.


+-------------------------------+
| Semáforo (contador = 3)       |
+-------------------------------+
|  [ ]  [ ]  [ ]                | <--- Permisos
+----+----+----+----------------+
     |    |    |
   Hilo Hilo Hilo

8. Matices útiles

Diferencias con otros primitivos

  • lock / Monitor / Mutex — permiten solo un hilo (acceso exclusivo).
  • Semaphore/SemaphoreSlim — permiten de forma limitada N hilos simultáneamente.

El semáforo no está ligado a un "propietario": cualquier hilo puede liberar el permiso. Es una característica, no un bug.

Aplicación en la vida real

  • Límite de conexiones paralelas a un servicio o BD.
  • Pool: no más de N hilos en un recurso.
  • Limitar peticiones web procesadas simultáneamente.
  • Límite de lectura/escritura para proteger de sobrecarga.
  • Restringir llamadas a una API externa.

Ejemplo de error (Release más que Wait)

var semaphore = new SemaphoreSlim(2);
semaphore.Release(); // ¡Error! El contador se hizo 3, superando MaxCount — se lanzará SemaphoreFullException.

Aquí habrá una SemaphoreFullException: el contador superó el máximo.

Diferencias entre Semaphore y SemaphoreSlim

  • SemaphoreSlim — dentro del proceso, más rápido y simple (úsalo casi siempre).
  • Semaphore — necesario para sincronización entre procesos (escenario raro).

¿Por qué aprender sobre semáforos?

Pregunta clásica en entrevistas: "¿Cómo limitar el número de hilos que usan un recurso?" — la respuesta correcta: semaforo.

  • lock — 1 hilo.
  • Semaphore/SemaphoreSlim — N hilos.

9. Errores típicos y particularidades al usar semáforos

Error №1: olvidan llamar a Release(). Si un hilo tomó un permiso (Wait() o WaitAsync()) y no lo liberó, los demás esperarán indefinidamente — la aplicación "se queda congelada".

Error №2: llaman a Release() más veces de las que hubo Wait(). Aparecen permisos "extra". Para Semaphore esto provocará SemaphoreFullException y lógica de acceso rota.

Error №3: mezclan distintos mecanismos de sincronización. En un sitio — lock, en otro — semáforo sobre el mismo recurso. Aumenta el riesgo de deadlocks.

Error №4: usan Semaphore en código asíncrono. El semáforo clásico no es amigo de async/await. Para escenarios asíncronos usa SemaphoreSlim y WaitAsync().

Error №5: configuran mal initialCount y maxCount. Con valores incorrectos el límite puede ser burlado y más hilos de los previstos accederán al recurso.

2
Tarea
C# SELF, nivel 56, lección 3
Bloqueada
Crea una aplicación de consola que simule el funcionamiento de un parking con 2 plazas disponibles.
Crea una aplicación de consola que simule el funcionamiento de un parking con 2 plazas disponibles.
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION