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 |
|---|---|---|---|
|
Sí | Más lento | Cuando se necesita sincronización entre procesos |
|
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.
GO TO FULL VERSION