1. El secreto del código multihilo resistente
Si imaginas la concurrencia como un equipo de varios trabajadores arreglando un coche al mismo tiempo, está claro: basta que uno agarre la herramienta de otro —y la reparación se para. En el código pasa lo mismo: un manejo descuidado de datos compartidos lleva a bugs ocultos que solo aparecen "en batalla".
En esta lección —cómo escribir código multihilo que no se derrumbe como un castillo de naipes. Y también: qué herramientas ayudan si algo sale mal.
1. Minimize las secciones críticas (lock)
Cuanto menos código esté dentro del bloqueo lock, mejor. Mientras un hilo mantiene el lock, los demás esperan.
Ejemplo:
// MAL: Toda la lógica de negocio dentro del lock — todos los hilos esperan
lock(_locker)
{
// Operación larga (no relacionada con el recurso compartido)
Thread.Sleep(500);
counter++;
}
// BIEN: Solo la acción mínima necesaria
// fuera del lock — todo el trabajo pesado fuera del bloqueo
Thread.Sleep(500);
lock(_locker)
{
counter++;
}
Vida real: Si dentro del lock hay una llamada a la red o un cálculo largo, el rendimiento cae en picado.
2. No uses como clave de bloqueo objetos genéricos
Hacer lock(this) o lock(typeof(MyClass)) — mala idea.
¿Por qué? Si alguien más usa ese mismo objeto para su propio bloqueo, obtendrás deadlocks o bugs ocultos. Usa siempre un objeto privado separado:
private readonly object _locker = new object();
lock(_locker)
{
// Tus acciones
}
Prohibido: strings (string), campos públicos, objetos de tipo-valor.
3. Usa siempre try...finally para liberar recursos capturados
Cualquier captura de Mutex, semáforo, ReaderWriterLockSlim — debe liberarse en finally.
_mutex.WaitOne();
try
{
// Sección crítica
}
finally
{
_mutex.ReleaseMutex();
}
4. No abuses de la sincronización
Sincroniza solo el acceso a recursos realmente compartidos (por ejemplo, colecciones), no cada pequeño movimiento. Locks excesivos convierten el código en una cola de espera.
5. Usa colecciones y tipos thread-safe
.NET ofrece colecciones especiales para escenarios multihilo: ConcurrentDictionary, ConcurrentQueue, ConcurrentBag, BlockingCollection y otras. Ya se protegen internamente.
using System.Collections.Concurrent;
ConcurrentDictionary<int, string> users = new ConcurrentDictionary<int, string>();
users.TryAdd(1, "Alice");
users[2] = "Bob";
6. Cuidado con deadlock (bloqueo mutuo)
La trampa típica — tomar varios locks en distinto orden.
// Hilo 1
lock(obj1)
{
lock(obj2)
{
// Hacemos algo
}
}
// Hilo 2
lock(obj2)
{
lock(obj1)
{
// Hacemos algo
}
}
Consejo: Siempre adquiere locks en el mismo orden en todos los hilos.
7. Cuando sea posible usa estado inmutable (immutable state)
Si un objeto no cambia su estado tras la creación — es seguro leerlo desde cualquier hilo. Ejemplos: string, Tuple, DateTime, tus DTOs solo de lectura.
2. Herramientas para diagnosticar problemas multihilo
Los bugs de sincronización son traicioneros: aparecen raramente e impredeciblemente. Usa herramientas y enfoques que ayuden a atraparlos y analizarlos.
1. Logging de eventos e hilos
Loggea el Thread.ManagedThreadId actual y las operaciones clave — es una forma simple de entender "quién y cuándo" entró/salió de la sección crítica.
Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] Entró en la sección crítica");
// ...
Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] Salió de la sección crítica");
Para aplicaciones reales usa Microsoft.Extensions.Logging, NLog, Serilog.
2. Thread Sanitizer & Race Detector
En .NET no hay un ThreadSanitizer "perfecto" integrado, pero hay herramientas útiles:
- JetBrains ReSharper — sus inspecciones atrapan algunos patrones peligrosos.
- Roslyn Analyzers — análisis estático del código.
- Concurrency Visualizer — analiza esperas/locks y carga de hilos.
3. Visual Studio Diagnostics Tools
Los profilers de Visual Studio ayudan a ver:
- qué hilos existen en la aplicación;
- dónde los hilos están inactivos (waiting);
- dónde aparecen bloqueos y contention por locks;
- cuándo surgen deadlocks y contention.
Toma trazas para obtener un grafo detallado de uso de locks.
4. Análisis de dumps y WinDbg
Si el servidor "se colgó", toma un dump del proceso y ábrelo en WinDbg o dotnet-dump. Por las pilas de llamadas ves dónde los hilos quedaron bloqueados y quién mantiene qué locks.
Ejemplo de análisis de stacks:
0:000> !syncblk
Index SyncBlock MonitorHeld Recursion Owning Thread Info SyncBlock Owner
1 000001d4b6f90e08 1 1 000001d4b5c941c0 000001d4b6f03458
(A los dumps suelen recurrir los "jedi" experimentados del deploy — no temas, es una herramienta poderosa.)
5. Unit-testing bajo carga (stress testing)
Ejecuta código multihilo en paralelo cientos/miles de iteraciones — así es más fácil encontrar races raras.
[Test]
public void Counter_IsThreadSafe()
{
var counter = 0;
var locker = new object();
var tasks = new List<Task>();
for (int i = 0; i < 100; i++)
{
tasks.Add(Task.Run(() =>
{
for (int j = 0; j < 10000; j++)
{
lock (locker)
{
counter++;
}
}
}));
}
Task.WaitAll(tasks.ToArray());
Assert.AreEqual(100 * 10000, counter);
}
6. Uso de asserts y comprobaciones especiales
Añade checks que garanticen estados correctos en debug. Por ejemplo, Debug.Assert al intentar capturar un recurso por segunda vez en el mismo hilo.
3. Conclusiones y recomendaciones
Esquema visual: zona peligrosa y seguridad
graph TD
A[Recurso compartido] -- sin sincronización --> B(Estado de race)
A -- bloqueo (lock/Mutex) --> C[Acceso seguro: sección crítica]
C -- "demasiados locks" --> D(Pérdida de rendimiento)
A -- ReaderWriterLockSlim --> E{Muchos lectores / Un escritor}
E -- "Lectura" --> F[Muchos hilos leen simultáneamente]
E -- "Escritura" --> G[Sólo uno escribe, los demás esperan]
Primitivos de sincronización y su propósito
| Primitivo | Para qué sirve | Cuántos hilos permite | Interprocesos | Rendimiento | Dónde usar |
|---|---|---|---|---|---|
|
Sección crítica simple | 1 | No | Muy alto | 99% de los casos |
|
La misma sección, pero entre procesos | 1 | Sí | Media | Files, IPC |
|
No más de N hilos | N | Sí | Media | Pools de recursos |
|
Lo mismo, pero más rápido, dentro del proceso | N | No | Alto | Pools en el código |
|
Muchos lectores, un escritor | Muchos/1 | No | Alto | Caches, settings |
GO TO FULL VERSION