CodeGym /Cursos /C# SELF /Mejores prácticas e herramientas para diagnóstico

Mejores prácticas e herramientas para diagnóstico

C# SELF
Nivel 57, Lección 4
Disponible

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:

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
lock (Monitor)
Sección crítica simple 1 No Muy alto 99% de los casos
Mutex
La misma sección, pero entre procesos 1 Sí Media Files, IPC
Semaphore
No más de N hilos N Sí Media Pools de recursos
SemaphoreSlim
Lo mismo, pero más rápido, dentro del proceso N No Alto Pools en el código
ReaderWriterLockSlim
Muchos lectores, un escritor Muchos/1 No Alto Caches, settings
2
Tarea
C# SELF, nivel 57, lección 4
Bloqueada
Eliminando el Livelock usando pausas aleatorias
Eliminando el Livelock usando pausas aleatorias
1
Cuestionario/control
Bloqueos mutuos, nivel 57, lección 4
No disponible
Bloqueos mutuos
Problemas típicos de la multihilación
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION