Introducción

Cuando alguien dice que “este servicio es thread-safe”, la frase afirma algo simple y serio: puede ser accedido por múltiples threads al mismo tiempo sin provocar corrupción de estado, resultados intermitentes ni condiciones de carrera. En producción, esto es un asunto de arquitectura, no solo una curiosidad académica. Un Singleton con un Dictionary interno puede funcionar en las pruebas y fallar en producción bajo carga. Una caché compartida sin control de concurrencia puede perder elementos sin ningún error visible. Y el problema no es nuevo: acompaña a aplicaciones web, workers, colas, servicios en segundo plano y procesamiento por lotes.

El objetivo de este artículo es mostrar exactamente cómo ocurre esto en dos plataformas muy usadas en el ecosistema moderno: .NET 10 y Python. En .NET, la respuesta suele pasar por System.Threading.Lock, Interlocked, ConcurrentDictionary y las decisiones de lifetime en DI. En Python, la conversación entra rápidamente en el GIL (Global Interpreter Lock), en el modelo de threading, en queue.Queue y, hoy, en un escenario más relevante: el Python free-threaded, que elimina parte de esa garantía y devuelve al desarrollador la responsabilidad directa de la sincronización.

La buena noticia es que el razonamiento es el mismo en ambos lados: el estado mutable compartido exige protección o la eliminación del compartir. Si el estado es inmutable, todo es más simple. Si el estado es compartido y mutable, necesitas pensar en invariantes, acceso atómico y testabilidad. Eso es lo que voy a mostrar aquí con ejemplos prácticos y con un patrón de prueba que demuestra si el servicio realmente soporta concurrencia.

⚠️ Atención: El problema no es “muchas threads al mismo tiempo” en sí. El problema es el acceso simultáneo a estado compartido sin una regla de sincronización. Sin ese detalle, cualquier servicio puede parecer estable en un entorno de laboratorio y romperse bajo carga real.

Comparación entre .NET 10 y Python en concurrencia, GIL y sincronización de estado compartido

Qué significa thread-safe en la práctica

Thread-safe es una propiedad del comportamiento del componente, no solo del lenguaje. Una implementación es thread-safe cuando, bajo cualquier interleaving válido de threads, la estructura de datos y el comportamiento observable siguen siendo consistentes. En otras palabras: el objeto sigue siendo correcto incluso cuando dos o más threads intentan usar el mismo recurso al mismo tiempo.

Para hacerlo más concreto, piensa en un contador simple:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
public class CounterService
{
    private int _count;

    public void Increment()
    {
        _count++;
    }

    public int GetValue()
    {
        return _count;
    }
}

Este código parece trivial. En la práctica, ++ sobre un entero no es una operación atómica. La secuencia real es algo así: leer el valor, sumar 1, escribirlo de vuelta. Si dos threads hacen esto al mismo tiempo, ambas pueden leer el mismo valor antiguo y escribir el mismo resultado final. El contador “pierde” un incremento, y el fallo se llama race condition.

Esto es importante porque muchos servicios de producción tienen estado compartido en un Singleton, en una caché en memoria, en un acumulador de estadísticas, en procesamiento por lotes y en colas. Cuando eso ocurre sin sincronización, el problema no es solo teórico: aparece como contadores inconsistentes, listas parcialmente llenas, diccionarios rotos o errores intermitentes que parecen aleatorios.

Cuatro propiedades que importan

Cuando trabajas con concurrencia, normalmente quieres responder cuatro preguntas:

  • ¿El estado puede ser accedido por múltiples threads al mismo tiempo?
  • ¿Esta operación tiene semántica atómica?
  • ¿La lectura y la escritura tienen visibilidad consistente entre threads?
  • ¿La mutación preserva las invariantes del objeto?

Si la respuesta a la primera es “sí”, necesitas considerar sincronización o inmutabilidad. La operación x++ falla en la primera y en la segunda. ConcurrentDictionary intenta resolver esto sin exigir un lock manual en cada operación. Interlocked resuelve el caso más simple de un contador o valor atómico.

.NET 10: qué cambió y cuándo usar System.Threading.Lock

En .NET, la forma clásica de proteger un bloque era usar lock sobre un objeto: lock (_lock) { ... }. Funciona, pero el patrón antiguo deja que el desarrollador escriba el soporte de sincronización de forma poco explícita. A partir de .NET 9, la biblioteca estándar empezó a ofrecer el tipo System.Threading.Lock, que deja la intención más clara.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
public sealed class CounterWithLock
{
    private readonly Lock _lock = new();
    private int _count;

    public void Increment()
    {
        lock (_lock)
        {
            _count++;
        }
    }

    public int GetValue()
    {
        lock (_lock)
        {
            return _count;
        }
    }
}

La idea de Lock es muy parecida al lock tradicional, pero la API tiene una intención más explícita y ayuda a evitar trampas de sincronización con objetos elegidos de forma ingenua. Esto es importante porque lock (this) o lock (new object()) suelen causar bugs reales en arquitectura. Lock también hace el código más legible y más específico respecto a lo que protege.

Cuándo usar lock y cuándo usar Interlocked

La regla práctica es simple:

  • usa lock cuando necesitas proteger un bloque de código con múltiples operaciones e invariantes más complejas;
  • usa Interlocked cuando solo necesitas proteger una variable primitiva con una operación simple.

Ejemplo con Interlocked:

1
2
3
4
5
6
7
8
public sealed class CounterWithInterlocked
{
    private int _count;

    public void Increment() => Interlocked.Increment(ref _count);

    public int GetValue() => Interlocked.CompareExchange(ref _count, 0, 0);
}

Interlocked opera a un nivel más bajo y evita contención innecesaria en operaciones simples. Es especialmente útil para contadores, flags de estado y reglas de sincronización rápidas. lock, en cambio, sigue siendo la herramienta correcta cuando la corrección exige aislar una secuencia de pasos y garantizar que toda la operación se ejecute de forma indivisible.

ConcurrentDictionary y colecciones concurrentes

Una parte importante de la thread-safety en .NET está en las colecciones del namespace System.Collections.Concurrent.

1
2
3
4
5
6
private readonly ConcurrentDictionary<string, int> _acessosPorChave = new();

_acessosPorChave.AddOrUpdate(
    key: "requests",
    addValue: _ => 1,
    updateValueFactory: (_, current) => current + 1);

Este patrón se usa en servicios de caché y agregaciones concurrentes. La idea es que la estructura ya sabe sincronizar internamente la escritura y la lectura. Es mucho mejor que un Dictionary compartido y accedido por varias threads, especialmente en escenarios de alta carga. En un singleton, un Dictionary común es una trampa clásica. En un servicio Scoped o Transient, generalmente no exigirá sincronización porque el objeto no se compartirá entre solicitudes.

DI en ASP.NET Core: Singleton es el punto crítico

El contenedor de DI de ASP.NET Core cambia las reglas del juego. El lifetime del servicio define si el mismo objeto será compartido por múltiples solicitudes o no.

Regla práctica

  • AddSingleton — el mismo objeto vive durante toda la aplicación. Si tiene estado mutable, debe ser thread-safe.
  • AddScoped — normalmente cada solicitud recibe su propia instancia. En general, no exige thread-safety.
  • AddTransient — crea una instancia por inyección. En general, tampoco exige thread-safety.

Esto es directo, pero la parte peligrosa es la siguiente: mucha gente registra una “caché en memoria” como singleton porque parece simple, pero después el mismo objeto es consultado y actualizado por múltiples solicitudes al mismo tiempo. El diseño lleva a race conditions, KeyNotFoundException inesperadas, listas mutables expuestas o simplemente datos inconsistentes.

Un ejemplo clásico:

1
2
3
4
5
6
7
8
9
builder.Services.AddSingleton<UserCache>();

public sealed class UserCache
{
    private readonly Dictionary<int, User> _users = new();

    public void Add(User user) => _users[user.Id] = user;
    public User? Get(int id) => _users.TryGetValue(id, out var user) ? user : null;
}

Este servicio parece inofensivo, pero no es thread-safe. Si la misma instancia es usada por múltiples solicitudes simultáneamente, la mutación del Dictionary causa problemas reales. La corrección es usar ConcurrentDictionary, ImmutableDictionary o encapsular la mutación en un lock cuando la operación exige una secuencia de pasos.

ℹ️ Información: DbContext nunca debe ser singleton por diseño. No es thread-safe y tampoco fue diseñado para compartirse entre solicitudes.

Python: el GIL y el mundo en el que no lo resuelve todo

En Python, el escenario es diferente. El intérprete CPython usa el GIL (Global Interpreter Lock), que serializa la ejecución de bytecode en cada proceso. En otras palabras, en una misma máquina con el intérprete estándar, el lenguaje evita que dos threads de Python interpreten bytecode al mismo tiempo.

Esto crea un mito recurrente: “si Python tiene GIL, entonces la aplicación es thread-safe por defecto”. Es falso. El GIL no resuelve invariantes compuestas y no hace que el código sea thread-safe en sentido arquitectónico. Solo impide la ejecución simultánea de bytecode Python dentro del mismo proceso.

El GIL ayuda en escenarios I/O-bound, como llamadas de red, archivos y sockets, porque una thread puede quedar esperando mientras otra se ejecuta. Pero no protege un objeto mutable compartido cuando la operación real exige varias etapas, y no da ninguna garantía de consistencia para estructuras mutables complejas.

Ejemplo clásico en Python:

1
2
3
4
5
6
7
counter = 0

# thread A
counter += 1

# thread B
counter += 1

Este código parece simple, pero no es atómicamente seguro en términos de semántica del programa. El GIL no garantiza que toda la secuencia de lectura + cálculo + escritura ocurra sin interferencias. Los detalles de implementación pueden variar y la corrección exige sincronización explícita con threading.Lock o una estructura diseñada para concurrencia.

Python 3.13 y el modo free-threaded

La comunidad Python lleva mucho tiempo discutiendo la idea de eliminar el GIL o hacerlo opcional. En 2023/2024, el proyecto pasó a una etapa más realista con el free-threaded Python (o Python ejecutándose sin GIL), un cambio importante para el ecosistema. Esto significa que, en algunas builds, múltiples threads pueden ejecutar bytecode Python en paralelo, lo que devuelve el problema de la sincronización al centro de la discusión.

En otras palabras:

  • con GIL, la concurrencia en Python sigue exigiendo cuidado;
  • sin GIL, la necesidad de sincronización explícita se vuelve más evidente;
  • el día a día real de la ingeniería sigue siendo: proteger el estado compartido y probar invariantes.

Primitivas de concurrencia en Python

Python ofrece opciones bien conocidas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import threading

lock = threading.Lock()
value = 0


def increment():
    global value
    with lock:
        value += 1

También existen:

  • threading.RLock — lock reentrante;
  • threading.Semaphore — limita el acceso concurrente;
  • threading.Event — señalización entre threads;
  • queue.Queue — cola thread-safe para comunicación producer/consumer;
  • concurrent.futures — ejecuta tareas en un pool de threads o procesos.

Estas herramientas tienen equivalencia conceptual con lo que ofrece .NET, pero la semántica del runtime cambia. En Python, especialmente en CPython, la arquitectura del GIL y la presencia del modo free-threaded pueden cambiar el nivel de paralelismo y las recomendaciones de diseño.

Comparativa lado a lado: .NET 10 vs Python

La tabla siguiente ayuda en el análisis práctico:

Necesidad.NET 10Python
Bloqueo simpleSystem.Threading.Lockthreading.Lock
Contador atómicoInterlocked.Incrementthreading.Lock o itertools.count
Diccionario concurrenteConcurrentDictionarydict con lock o queue
Límite de concurrenciaSemaphoreSlimthreading.Semaphore
Cola productor/consumidorChannel<T>queue.Queue / asyncio.Queue
Estado inmutableImmutableDictionaryfrozenset, tuple, MappingProxyType
Paralelismo asíncronoTask, awaitasyncio, ThreadPoolExecutor
Procesamiento CPU-boundParallel.ForEach, TaskProcessPoolExecutor

La principal diferencia conceptual es esta: en .NET, el modelo de threads y el memory model son más explícitos; en Python, la existencia del GIL y del modelo cooperativo de asyncio crea más capas de abstracción. Pero, en ambos casos, el problema es el mismo: la sincronización debe existir cuando tienes estado mutable compartido.

Cómo probar si un servicio es thread-safe

La mejor forma de probar no es “mirar el código” y concluir que parece seguro. La mejor forma es construir una prueba de estrés con múltiples threads, ejecutar muchas operaciones y validar una invariante. El patrón es simple: N threads, K iteraciones, un total esperado y una aserción que garantice que el valor final sea siempre el mismo.

En .NET, queda así:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static void ExecutarConcorrencia(IContadorService contador)
{
    const int threads = 32;
    const int iteracoes = 50_000;
    var barreira = new Barrier(threads);

    var tarefas = Enumerable.Range(0, threads)
        .Select(_ => Task.Run(() =>
        {
            barreira.SignalAndWait();
            for (var i = 0; i < iteracoes; i++)
            {
                contador.Incrementar();
            }
        }))
        .ToArray();

    Task.WaitAll(tarefas);

    var totalEsperado = (long)threads * iteracoes;
    Console.WriteLine($"Esperado: {totalEsperado} | Atual: {contador.Valor}");
}

Si la implementación es insegura, el total final será menor que el esperado en algunas ejecuciones. Es típico de una race condition: el problema aparece de forma probabilística e intermitente. No basta con ejecutarlo una vez. Vale la pena repetir varias rondas para validar.

Eso es exactamente lo que demuestra el repositorio de ejemplos del blog: un servicio sin protección, un servicio con Lock y un servicio con Interlocked. El mismo patrón es fácil de repetir en Python con threading.Thread y threading.Lock.

📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog: BlogSamples/AsyncParallel/ThreadSafety/

Ejemplo práctico en C#

A continuación hay un ejemplo mínimo con dos versiones del mismo servicio: una insegura y otra segura. El objetivo aquí no es mostrar un framework completo, sino demostrar el concepto con precisión.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public interface IContadorService
{
    void Incrementar();
    long Valor { get; }
}

public sealed class ContadorNaoSeguro : IContadorService
{
    private long _valor;

    public long Valor => _valor;

    public void Incrementar() => _valor++;
}

public sealed class ContadorComLock : IContadorService
{
    private readonly Lock _sincronizacao = new();
    private long _valor;

    public long Valor
    {
        get
        {
            lock (_sincronizacao)
            {
                return _valor;
            }
        }
    }

    public void Incrementar()
    {
        lock (_sincronizacao)
        {
            _valor++;
        }
    }
}

La estructura anterior ya explica mucho. La versión insegura pierde incrementos bajo concurrencia; la versión protegida mantiene el valor consistente. El siguiente paso, en un servicio real, es decidir si la solución correcta es lock, Interlocked, ConcurrentDictionary o inmutabilidad completa. Eso depende del tipo de operación y del grado de mutación que el objeto necesita soportar.

Ejemplo realista: ConcurrentDictionary en un singleton

Un singleton que agrega estadísticas es un caso clásico de uso correcto de ConcurrentDictionary:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
public sealed class EstatisticasService
{
    private readonly ConcurrentDictionary<string, long> _contagemPorChave = new();

    public void Registrar(string chave, long incremento = 1)
    {
        _contagemPorChave.AddOrUpdate(
            chave,
            _ => incremento,
            (_, atual) => atual + incremento);
    }

    public long Obter(string chave) =>
        _contagemPorChave.TryGetValue(chave, out var valor) ? valor : 0;
}

Este patrón es muy útil cuando la aplicación registra eventos, métricas, contadores por usuario o por endpoint. La estructura ya implementa la sincronización interna, así que el servicio puede seguir siendo un singleton sin convertirse en una fuente de race conditions.

Consejos y buenas prácticas

  • Prefiere la inmutabilidad siempre que sea posible. Los objetos inmutables son más fáciles de compartir sin sincronización.
  • En .NET 10, prefiere System.Threading.Lock en bloques complejos en lugar de usar objetos arbitrarios como sincronizadores.
  • En un Singleton, asume que el estado mutable necesita protección; en Scoped y Transient, la mayoría de las instancias no se comparten.
  • En Python, el GIL no es lo mismo que thread-safety; sincroniza siempre que el estado compartido sea mutable.
  • Prueba la concurrencia con múltiples threads y aserciones sobre invariantes, no solo con ejecución unitaria simple.
  • Cuando el patrón lo exija en cada operación, usa ConcurrentDictionary, Channel<T> o colas en lugar de Dictionary y List expuestos.
  • Devuelve snapshots al exponer estado interno para lectura; evita devolver diccionarios o listas mutables del objeto compartido.

Resumen Objetivo

  • Thread-safety — es la garantía de que un componente mantiene un estado consistente incluso bajo acceso simultáneo de múltiples threads.
  • System.Threading.Lock en .NET 10 — ofrece una primitiva explícita y más legible para proteger bloques de código e invariantes complejas.
  • Interlocked — es ideal para contadores simples y operaciones atómicas de una sola variable, sin bloquear todo el sistema.
  • Singleton en ASP.NET Core — exige atención redoblada porque el mismo servicio puede atender múltiples solicitudes en paralelo.
  • Dictionary y List en un singleton — son ejemplos clásicos de código que funciona en pruebas y falla en producción bajo carga.
  • El GIL en Python — ayuda en algunas situaciones, pero no sustituye la sincronización de estado compartido ni elimina las race conditions.
  • Python free-threaded — refuerza aún más que la sincronización explícita sigue siendo responsabilidad del desarrollador.
  • Prueba de concurrencia — N threads × K iteraciones con verificación de invariante es la forma más fiable de determinar si el servicio realmente soporta carga.

Lee También

Referencias