CodeGym /Cursos /C# SELF /Introducción a las colecciones Concurrent

Introducción a las colecciones Concurrent

C# SELF
Nivel 58, Lección 0
Disponible

1. Antecedentes del problema

En una aplicación single-thread, colecciones como List<T> o Dictionary<T> se comportan de forma predecible. Pero tan pronto como varios hilos empiezan a acceder a la misma colección simultáneamente, aparece el problema conocido: race conditions.

Si varios hilos intentan leer y/o escribir en la misma colección sin la sincronización adecuada, puedes obtener:

  • Datos incorrectos: un elemento pudo ser eliminado por un hilo mientras otro intentaba actualizarlo.
  • Pérdida de datos: un hilo añadió un elemento y otro lo sobrescribió sin conocer la escritura previa.
  • Excepciones: la colección puede quedar en un estado inválido y recibirás InvalidOperationException (por ejemplo, "Collection was modified; enumeration operation may not execute.") o incluso NullReferenceException.

Ejemplo 1: Race condition en List<T> (suma simple)

Dos hilos incrementan simultáneamente el mismo elemento de la lista.

using System.Collections.Generic;
using System.Threading.Tasks; // Para Task.Run

class RaceConditionExample
{
    static List<int> numbers = new List<int> { 0 }; // Lista con un elemento

    static void Main(string[] args)
    {
        Console.WriteLine("Valor inicial: " + numbers[0]); // 0

        // Lanzamos dos hilos, cada uno incrementa numbers[0]
        Task task1 = Task.Run(() => IncrementNumbers(500_000));
        Task task2 = Task.Run(() => IncrementNumbers(500_000));

        Task.WaitAll(task1, task2); // Esperamos a que terminen ambos hilos

        Console.WriteLine("Valor final: " + numbers[0]); // Esperamos 1_000_000, pero...
        // ¡El resultado casi siempre será menor que 1_000_000!
    }

    static void IncrementNumbers(int count)
    {
        for (int i = 0; i < count; i++)
        {
            // Esta operación "numbers[0]++" en realidad consiste en 3 pasos:
            // 1. Leer numbers[0]
            // 2. Incrementar el valor en 1
            // 3. Escribir el nuevo valor de vuelta en numbers[0]
            numbers[0]++; 
        }
    }
}

¿Por qué es una carrera? Si el hilo A leyó numbers[0] (valor 0), y luego el hilo B leyó numbers[0] (también 0) antes de que A escribiera 1, ambos incrementan 0 a 1 y escriben 1. Se pierde un incremento. La operación numbers[0]++ no es atómica.

Ejemplo 2: InvalidOperationException al modificar Dictionary

Un hilo itera el diccionario, otro lo modifica.

using System.Collections.Generic;
using System.Threading; // Para Thread.Sleep

class DictionaryRaceExample
{
    static Dictionary<int, string> users = new Dictionary<int, string>();

    static void Main(string[] args)
    {
        // Inicialización del diccionario
        for (int i = 0; i < 5; i++) users.Add(i, $"User {i}");

        // Hilo-lector
        Thread readerThread = new Thread(() =>
        {
            try
            {
                foreach (var user in users) // Iteración sobre el diccionario
                {
                    Console.WriteLine($"Lector: {user.Key} - {user.Value}");
                    Thread.Sleep(10); // Simula trabajo
                }
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine($"Lector: ¡ERROR! {ex.Message}");
            }
        });

        // Hilo-escritor
        Thread writerThread = new Thread(() =>
        {
            Thread.Sleep(5); // Dar un poco de tiempo al lector para empezar
            for (int i = 5; i < 10; i++)
            {
                users.Add(i, $"New User {i}"); // Añadimos elementos
                Console.WriteLine($"Escritor: Añadió User {i}");
                Thread.Sleep(15);
            }
        });

        readerThread.Start();
        writerThread.Start();

        readerThread.Join(); // Esperamos a que terminen los hilos
        writerThread.Join();
        Console.WriteLine("Ejemplo completado.");
    }
}

¿Por qué ocurre el error? Dictionary<TKey, TValue> (al igual que List<T>) no está pensado para lecturas y escrituras concurrentes por distintos hilos sin sincronización. Cuando el hilo escritor cambia la estructura interna, el hilo lector sigue el foreach sobre datos ya modificados, lo que provoca InvalidOperationException.

2. ¿Por qué los bloqueos simples (lock) no siempre son óptimos?

La idea de "encerrar todo en un lock" parece sencilla, pero tiene inconvenientes:

// Mal ejemplo: demasiada sección crítica
// (Solo para demostración, no se debe hacer así)
static object _lock = new object();
static List<int> _sharedList = new List<int>();

void AddItem(int item)
{
    lock (_lock)
    {
        _sharedList.Add(item);
    }
}

int GetItemCount()
{
    lock (_lock)
    {
        return _sharedList.Count;
    }
}
  • Rendimiento (bottleneck): lock bloquea el acceso a toda la colección. Con 100 hilos, 99 estarán esperando a uno, incluso si las operaciones no entran en conflicto directamente.
  • Complejidad: hay que recordar el lock en cada sitio donde se usa la colección. Un sitio olvidado — y la race vuelve.
  • Deadlocks: varios lock en distintos objetos pueden fácilmente llevar a un deadlock.
  • Iteradores: foreach no salva si otro hilo modifica la colección.

Por eso en .NET se introdujeron colecciones diseñadas para thread-safety.

Operaciones atómicas

Una colección thread-safe garantiza funcionamiento correcto con accesos concurrentes desde varios hilos sin locks externos por parte del usuario. La clave son las operaciones atómicas: una acción se hace completamente o no se hace — otros hilos no ven "estados intermedios".

  • Añadir, eliminar, leer — se comportan como si se ejecutaran uno a la vez.
  • Internamente usan técnicas de bajo nivel: operaciones interlockeadas (Interlocked), Compare-And-Swap (CAS), locks finos — en lugar de bloquear toda la colección globalmente.

3. Resumen de System.Collections.Concurrent

El namespace System.Collections.Concurrent provee un conjunto de colecciones construidas desde cero para multihilo. Su filosofía: máximo paralelismo y mínimo locking.

  • Rendimiento: escalan con el número de cores.
  • Simplicidad: no necesitas poner lock manualmente alrededor de cada operación.
  • Menos errores: reduces la clase de problemas asociados a la sincronización manual.
  • Optimización para concurrencia: funcionan eficazmente con añadidos/eliminados concurrentes.

4. Clases principales

ConcurrentQueue<T> (cola thread-safe)

Principio: FIFO — "primero en entrar, primero en salir". Escenarios: producer–consumer, logging, colas de tareas.

using System.Collections.Concurrent;

ConcurrentQueue<string> messageQueue = new ConcurrentQueue<string>();

void Producer() => messageQueue.Enqueue("Mensaje 1");

void Consumer()
{
    if (messageQueue.TryDequeue(out string message))
    {
        Console.WriteLine($"Procesado: {message}");
    }
    else
    {
        Console.WriteLine("La cola está vacía.");
    }
}

ConcurrentStack<T> (stack thread-safe)

Principio: LIFO — "último en entrar, primero en salir". Escenarios: historial de acciones, DFS, object pools.

using System.Collections.Concurrent;

ConcurrentStack<int> historyStack = new ConcurrentStack<int>();

void PushAction(int value) => historyStack.Push(value);

void PopAction()
{
    if (historyStack.TryPop(out int action))
    {
        Console.WriteLine($"Acción deshecha: {action}");
    }
    else
    {
        Console.WriteLine("El stack está vacío.");
    }
}

ConcurrentBag<T> (bolsa thread-safe)

Colección no ordenada, el orden no está garantizado. Optimizada para el patrón "el hilo suele tomar lo que él mismo puso". Ideal para pools.

using System.Collections.Concurrent;

ConcurrentBag<System.Guid> objectPool = new ConcurrentBag<System.Guid>();

void AddObject() => objectPool.Add(System.Guid.NewGuid());

void TakeObject()
{
    if (objectPool.TryTake(out System.Guid obj))
    {
        Console.WriteLine($"Tomado objeto: {obj}");
    }
    else
    {
        Console.WriteLine("El pool está vacío.");
    }
}

ConcurrentDictionary<TKey, TValue> (diccionario thread-safe)

Soporta operaciones atómicas de añadir, actualizar y obtener por clave. Perfecto para caches, sesiones, contadores.

using System.Collections.Concurrent;

ConcurrentDictionary<string, int> userScores = new ConcurrentDictionary<string, int>();

void UpdateScore(string user, int score)
{
    // Añade atómicamente si no existe, o actualiza si existe
    userScores.AddOrUpdate(user, score, (key, existingVal) => existingVal + score);
    Console.WriteLine($"Puntuación {user}: {userScores[user]}");
}

void GetScore(string user)
{
    if (userScores.TryGetValue(user, out int score))
    {
        Console.WriteLine($"Puntuación actual de {user}: {score}");
    }
    else
    {
        Console.WriteLine($"Usuario {user} no encontrado.");
    }
}

5. ¿Cuándo usar estas colecciones en lugar de las normales?

  • Aplicación multihilo: en una sola hebra las colecciones normales son más rápidas (sin overhead).
  • Una colección compartida por varios hilos: es la señal principal para usar System.Collections.Concurrent.
  • Necesitas alto rendimiento y escalabilidad: las colecciones están diseñadas para minimizar esperas.
  • Quieres simplificar el código: sin locks manuales alrededor de cada operación.
  • Necesitas operaciones atómicas: añadir/eliminar/obtener no dejarán la colección en un estado inconsistente.

No uses colecciones Concurrent cuando:

  • La aplicación es estrictamente single-thread.
  • Necesitas "transaccionalidad" de varias operaciones relacionadas (quizá hace falta sincronización externa u otros mecanismos).
  • Es crucial el orden estricto de extracción donde ese orden no está garantizado (por ejemplo, en ConcurrentBag<T>).
2
Tarea
C# SELF, nivel 58, lección 0
Bloqueada
Añadiendo elementos a ConcurrentQueue
Añadiendo elementos a ConcurrentQueue
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION