1. Las clásicas condiciones de Coffman
En 1971 el científico de la computación Edward Coffman (Edward G. Coffman Jr.) describió cuatro condiciones sin las cuales el deadlock es imposible. Estas reglas hace tiempo que son el "abecé" en entrevistas y cursos sobre multithreading. Vale la pena no solo memorizarlas, sino entender por qué existen:
- Mutual Exclusion (Exclusión mutua): al menos un recurso sólo puede ser poseído por un hilo a la vez.
- Hold and Wait (Retener y esperar): un hilo que ha tomado un recurso puede esperar por otros recursos.
- No Preemption (No preempción): no se puede arrebatar un recurso a un hilo por la fuerza — sólo el propio hilo puede liberarlo.
- Circular Wait (Espera circular): existe una cadena de hilos donde cada uno espera un recurso que posee el siguiente.
Si se cumplen las cuatro condiciones, el deadlock es posible. Si rompemos al menos una — la posibilidad de bloqueo mutuo desaparece.
Decisiones rápidas
flowchart TD
A[¿Necesitas bloquear varios recursos?] -- No --> B[lock estándar]
A -- Sí --> C[¿Se pueden siempre adquirir en un mismo orden?]
C -- Sí --> D[Siempre tomar en un mismo orden]
C -- No --> E[Evitar locks anidados]
D --> F[Minimizar tiempo bajo lock]
E --> F
B --> F
F --> G{¿Sigue dando miedo?}
G -- Sí --> H[Agregar timeouts y reintentos]
G -- No --> I[¡Duerme tranquilo!]
2. Estrategias principales para prevenir Deadlock
Como el deadlock es una parte inherente del mundo multihilo, nuestra tarea es aprender a convivir con él. Diversas estrategias ayudan: desde las más sencillas hasta las más astutas.
Siempre bloquea recursos en el mismo orden
La idea es simple: si todos los hilos siempre adquieren los recursos en el mismo orden, la espera circular no puede formarse. Esta técnica suele llamarse ordered locking — "bloqueo ordenado".
Ejemplo
Código peligroso:
// Hilo 1
lock (resA)
{
lock (resB)
{
// ...
}
}
// Hilo 2
lock (resB)
{
lock (resA)
{
// ...
}
}
Aquí es posible un deadlock: el primer hilo agarró resA y espera resB, el segundo al revés. Ambos quedan colgados y nunca liberan.
Código correcto:
// Siempre: primero resA, luego resB (nunca al revés)
lock (resA)
{
lock (resB)
{
// ...
}
}
Ahora el orden es único y el deadlock es imposible. No importa cuántos recursos tengas ni cómo se llamen — lo importante es que todos los hilos tomen los locks en el mismo orden.
Error típico: si en algún lugar del código aparece una excepción al orden, el riesgo de deadlock vuelve. Así que ojo.
Evita bloquear varios recursos al mismo tiempo
Esto es lo más sencillo: si puedes no tomar locks sobre dos o más recursos a la vez — no los tomes. Cuantos más locks anidados, mayor es la probabilidad de quedarte atascado. En vez de eso puedes, por ejemplo, copiar los datos necesarios a variables temporales, liberar el lock y luego trabajar con los demás recursos.
Usa timeouts al adquirir un lock
Si realmente necesitas tomar varios locks, los timeouts ayudan. Por ejemplo, en vez del lock normal usa métodos que permitan "intentar" obtener el lock y, si no se consigue, deshacer todo con cuidado, por ejemplo Monitor.TryEnter.
object resourceA = new object();
object resourceB = new object();
bool successA = false, successB = false;
try
{
// Intentamos tomar ambos locks como máximo 2 segundos
successA = Monitor.TryEnter(resourceA, TimeSpan.FromSeconds(2));
if (!successA) return; // no se pudo, salimos
successB = Monitor.TryEnter(resourceB, TimeSpan.FromSeconds(2));
if (!successB) return;
// Sección crítica
}
finally
{
if (successB) Monitor.Exit(resourceB);
if (successA) Monitor.Exit(resourceA);
}
Si no se puede tomar el segundo lock en 2 segundos, liberamos el primero y salimos. Al final no habrá deadlock, solo algunos hilos revertirán sus intentos.
Minimiza la cantidad de código dentro del lock
Cuanto más pequeño sea el trozo de código "bajo el lock", menos tiempo otros hilos estarán esperando. No hagas cálculos complejos, llamadas de red o IO dentro de la sección crítica. Agarra el lock — modifica el recurso compartido rápido — suelta. Todo lo demás hagámoslo fuera.
Separa el estado — evita recursos compartidos
A veces es mejor no pelear con locks y simplemente evitar el estado compartido:
- Usa objetos inmutables (immutable).
- Trabaja con copias o variables locales en vez de globales.
- Pasa datos mediante mensajes (Actor Model, cola de mensajes).
- Usa colecciones thread-safe: ConcurrentDictionary, ConcurrentQueue y otras de System.Collections.Concurrent.
3. Resolver Deadlock si ya ocurrió
Matar y reiniciar manualmente (no es la mejor opción)
La manera más simple es terminar todos los procesos bloqueados. Pero esto conlleva riesgo de pérdida de datos. Es un caso extremo que conviene evitar.
Detección de Deadlock en tiempo de ejecución
Algunos sistemas permiten detectar deadlocks automáticamente. Si un hilo no puede adquirir un lock durante demasiado tiempo, puede loguear el evento, notificar al sistema de monitorización e iniciar la recuperación.
if (!Monitor.TryEnter(resource, TimeSpan.FromSeconds(10)))
{
Console.WriteLine("Parece que estamos en un deadlock o alguien tiene el lock demasiado tiempo!");
// Se puede iniciar recuperación, volcar un dump o notificar al usuario
}
En sistemas distribuidos se usan detectores dedicados que analizan el grafo de esperas y forzan la liberación de transacciones colgadas.
Rollback automático y reintento
Una práctica cómoda es "rendirse" y volver a intentar: si no se pueden tomar todos los locks en un tiempo razonable, hacemos rollback, esperamos un poco (a menudo un tiempo aleatorio para desincronizar intentos) y reintentamos.
for (int attempt = 0; attempt < 3; attempt++)
{
bool gotRes1 = Monitor.TryEnter(res1, TimeSpan.FromSeconds(2));
bool gotRes2 = false;
try
{
if (gotRes1)
{
gotRes2 = Monitor.TryEnter(res2, TimeSpan.FromSeconds(2));
if (gotRes2)
{
// Sección crítica
break;
}
}
}
finally
{
if (gotRes2) Monitor.Exit(res2);
if (gotRes1) Monitor.Exit(res1);
}
// No funcionó — esperamos y probamos otra vez
Thread.Sleep(500 + new Random().Next(500));
}
4. Buenas prácticas y recomendaciones
- Analiza el orden de adquisición de locks. Reúne los puntos de entrada y verifica el orden.
- Usa cuando sea posible las colecciones de System.Collections.Concurrent.
- Usa herramientas de análisis de código. IDEs como Rider o Visual Studio ayudan a encontrar locks anidados.
- Loguea intentos largos de adquisición.
- Realiza pruebas de estrés para componentes multihilo.
- Documenta las convenciones sobre el orden de locks. Los comentarios salvan de romper la ordenación.
5. Ejemplos prácticos
Ejemplo: Base de datos
En una BD el deadlock es un visitante frecuente: dos transacciones actualizan las mismas tablas pero en distinto orden (A→B y B→A). La mayoría de motores detectan estas situaciones y "matan" una de las transacciones.
Ejemplo: Métodos asincrónicos
En .NET, si mezclas async y locks, puedes provocar deadlocks: await puede suspender el hilo que mantiene un lock, mientras otro hilo espera ese mismo recurso. Planea bien los límites de las secciones críticas y evita awaits dentro de ellas.
6. Errores típicos al trabajar con locks
Error nº1: bloquear strings.
lock (myString) — mala idea. En .NET las cadenas están internadas, así que en la práctica estás bloqueando la tabla global de internamiento de strings.
Error nº2: distinto orden de adquisición.
Si en distintos sitios del programa los locks se toman en distinto orden, la probabilidad de deadlock aumenta drásticamente.
Error nº3: locks demasiado largos.
Mantener un lock más tiempo del necesario, o llamar a métodos externos desde la sección crítica — es la forma segura de provocar bloqueos y deadlocks.
GO TO FULL VERSION