Introducción

Imagina la portería de una gran empresa — una corporación centenaria con decenas de sedes y 80.000 empleados activos en el registro. Son las 8 de la mañana de un lunes: cientos de personas llegan al mismo tiempo, cada una acercando su credencial a los torniquetes electrónicos. Para cada credencial, el sistema debe realizar una validación contra la base de datos corporativa: buscar el registro, verificar la situación, comprobar los permisos de acceso y registrar la entrada.

Si ese sistema es secuencial — procesando una validación a la vez, en fila — las personas se van a amontonar en la entrada. Con 80.000 registros y un tiempo de búsqueda de algunos milisegundos por consulta, la matemática es cruel. Aquí entra el paralelismo.

A diferencia de la programación asíncrona — que consiste en liberar el thread mientras se espera la I/O (lee más en Programación Asíncrona en C#: async/await y Threads) — el paralelismo consiste en usar múltiples núcleos de CPU simultáneamente para procesar tareas al mismo tiempo. Es la estrategia correcta cuando el cuello de botella está en el procesamiento y no en la espera de I/O.

En este artículo vas a entender qué es el paralelismo, cómo funciona en .NET, qué herramientas usar (Parallel.ForEach, PLINQ, Task.Run), cómo evitar las trampas clásicas de concurrencia y, sobre todo, cuándo tiene sentido usar cada enfoque — todo anclado en el ejemplo del torniquete corporativo.

📦 Código fuente: La implementación completa de este artículo está en el repositorio blog-zocateli-sample en GitHub. Clónalo, explóralo y adáptalo a tu contexto.


Requisitos Previos


El Problema: El Torniquete Corporativo

Antes de escribir una línea de código, quiero entender el problema concreto.

La empresa TechCorp Centenária S.A. tiene:

  • 80.000 empleados activos en 12 sedes
  • Una base de datos corporativa legada con registros de control de acceso
  • 200 torniquetes distribuidos en las entradas de todos los edificios
  • Pico de acceso: 2.000 empleados presentándose en los primeros 15 minutos del turno

El sistema actual es simple: cuando se lee la credencial, se hace una búsqueda secuencial en una lista en memoria cargada desde la base de datos. El código original es este:

 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
// ❌ ENFOQUE SECUENCIAL — cuello de botella en grandes volúmenes
public class ValidadorDeAcesso
{
    private readonly List<RegistroFuncionario> _registros;

    public ValidadorDeAcesso(List<RegistroFuncionario> registros)
    {
        _registros = registros;
    }

    public ResultadoValidacao ValidarTodos(IEnumerable<string> cracharIds)
    {
        var resultados = new List<ResultadoCracha>();

        foreach (var id in cracharIds)
        {
            // Procesamiento secuencial: uno a la vez
            var registro = _registros.FirstOrDefault(r => r.CrachaId == id);
            var resultado = ProcessarValidacao(registro, id);
            resultados.Add(resultado);
        }

        return new ResultadoValidacao(resultados);
    }

    private ResultadoCracha ProcessarValidacao(RegistroFuncionario? registro, string id)
    {
        if (registro is null)
            return new ResultadoCracha(id, Acesso.Negado, "Credencial no encontrada");

        // Simula la validación de reglas de negocio (verificación de estado, horario, etc.)
        ValidarStatusContratual(registro);
        ValidarHorarioPermitido(registro);
        ValidarPermissaoUnidade(registro);

        return new ResultadoCracha(id, Acesso.Permitido, registro.NomeFuncionario);
    }
}

Con 80.000 registros y 2.000 validaciones llegando casi simultáneamente, el loop foreach procesa una a la vez. Es un problema CPU-bound: el procesador está trabajando, no esperando — pero está trabajando solo, en un único núcleo.

💡 Consejo: Distingue los problemas antes de elegir la solución. Pregúntate: “¿mi proceso está esperando datos (I/O-bound) o procesando datos (CPU-bound)?” Para I/O-bound usa async/await. Para CPU-bound usa paralelismo.


Asíncrono vs Paralelo: la Diferencia que lo Cambia Todo

Es fundamental tener clara esta distinción antes de continuar:

Programación AsíncronaParalelismo
ResuelveCuellos de botella de espera (I/O)Cuellos de botella de procesamiento (CPU)
CómoLibera el thread durante la esperaUsa múltiples threads simultáneos
Herramientaasync/await, TaskParallel, PLINQ, Task.Run
EjemploConsulta a la base de datosProcesar 80k registros en memoria
Núcleos usadosEficiente con 1 núcleoAprovecha todos los núcleos disponibles

En el problema del torniquete:

  • Consultar la base de datos para cargar los registros → asíncrono (ToListAsync())
  • Procesar/validar los 80.000 registros en memoria → paralelo (Parallel.ForEach)

Procesamiento secuencial (1 thread, ~420ms) vs Parallel.ForEach (8 threads, ~68ms) validando 80 mil registros

Muchas soluciones reales combinan los dos patrones, y lo verás a lo largo de este artículo.


Cómo Funciona el Paralelismo en .NET

.NET administra los threads a través del ThreadPool — un conjunto de threads preasignados listos para usar. Cuando usas Parallel.ForEach o Task.Run, el runtime distribuye el trabajo entre los threads disponibles en el pool, mapeándolos a los núcleos físicos de la CPU.

Particionamiento Automático

La mayor ventaja de Parallel en .NET es el particionamiento automático: el runtime divide la colección en bloques (chunks) y distribuye cada bloque a un thread diferente. Esto evita el overhead de crear un thread por elemento.

1
2
3
4
CPU Core 1: Thread T1 → procesa elementos [0 ... 19.999]
CPU Core 2: Thread T2 → procesa elementos [20.000 ... 39.999]
CPU Core 3: Thread T3 → procesa elementos [40.000 ... 59.999]
CPU Core 4: Thread T4 → procesa elementos [60.000 ... 79.999]

En una máquina con 8 núcleos, 80.000 registros se dividirían en ~8 particiones de 10.000, reduciendo el tiempo de procesamiento hasta 8x (en la práctica un poco menos por el overhead de sincronización).


Parallel.ForEach — La Solución para el Torniquete

La herramienta más directa para paralelizar un foreach es Parallel.ForEach. Así se transforma el código secuencial:

 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
using System.Collections.Concurrent;
using System.Threading.Tasks;

public class ValidadorDeAcessoParalelo
{
    private readonly List<RegistroFuncionario> _registros;

    public ValidadorDeAcessoParalelo(List<RegistroFuncionario> registros)
    {
        _registros = registros;
    }

    public ResultadoValidacao ValidarTodos(IEnumerable<string> cracharIds)
    {
        // ConcurrentBag: colección thread-safe para acumular resultados
        var resultados = new ConcurrentBag<ResultadoCracha>();

        Parallel.ForEach(cracharIds, id =>
        {
            // Cada iteración puede ejecutarse en un thread diferente simultáneamente
            var registro = _registros.FirstOrDefault(r => r.CrachaId == id);
            var resultado = ProcessarValidacao(registro, id);
            resultados.Add(resultado); // Thread-safe: ConcurrentBag
        });

        return new ResultadoValidacao(resultados.ToList());
    }
}

⚠️ Atención: Observa el uso de ConcurrentBag<T> en lugar de List<T>. Una List<T> común no es thread-safe — múltiples threads agregando elementos simultáneamente causarían corrupción de datos o excepciones. Usa siempre colecciones del namespace System.Collections.Concurrent en escenarios paralelos.

Controlando el Grado de Paralelismo

Por defecto, .NET usa todos los núcleos disponibles. En producción, eso puede ser demasiado agresivo — tal vez quieras limitarlo para no saturar el servidor ni afectar otros procesos:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
public ResultadoValidacao ValidarComLimite(IEnumerable<string> cracharIds, int maxThreads = 4)
{
    var resultados = new ConcurrentBag<ResultadoCracha>();

    var opcoes = new ParallelOptions
    {
        MaxDegreeOfParallelism = maxThreads // Limita el número de threads simultáneos
    };

    Parallel.ForEach(cracharIds, opcoes, id =>
    {
        var registro = _registros.FirstOrDefault(r => r.CrachaId == id);
        var resultado = ProcessarValidacao(registro, id);
        resultados.Add(resultado);
    });

    return new ResultadoValidacao(resultados.ToList());
}

💡 Consejo: Un buen punto de partida para MaxDegreeOfParallelism es Environment.ProcessorCount (número de núcleos lógicos de la máquina) o Environment.ProcessorCount / 2 para dejar margen a otros procesos.


Acelerando la Búsqueda: Estructuras de Datos Correctas

Antes de paralelizar, verifica que la estructura de datos no sea el cuello de botella. En el ejemplo del torniquete, FirstOrDefault sobre una List<T> tiene complejidad O(n) — recorre toda la lista hasta encontrar el elemento. Con 80.000 registros, eso es caro.

La solución es preindexar los datos en un Dictionary<string, RegistroFuncionario>:

 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
public class ValidadorOtimizado
{
    // Dictionary permite búsqueda O(1) — tiempo constante, independiente del tamaño
    private readonly Dictionary<string, RegistroFuncionario> _indice;

    public ValidadorOtimizado(List<RegistroFuncionario> registros)
    {
        // Construir el índice una sola vez en la inicialización
        _indice = registros.ToDictionary(r => r.CrachaId);
    }

    public ResultadoValidacao ValidarTodos(IEnumerable<string> cracharIds)
    {
        var resultados = new ConcurrentBag<ResultadoCracha>();

        Parallel.ForEach(cracharIds, id =>
        {
            // O(1) en lugar de O(n) — mejora drástica
            _indice.TryGetValue(id, out var registro);
            resultados.Add(ProcessarValidacao(registro, id));
        });

        return new ResultadoValidacao(resultados.ToList());
    }
}

ℹ️ Información: Dictionary<TKey, TValue> no es thread-safe para escritura, pero es seguro para lecturas concurrentes cuando el diccionario no se está modificando. Como el índice se construye una sola vez y solo se lee en paralelo, este patrón es correcto. Si necesitas escritura concurrente, usa ConcurrentDictionary<TKey, TValue>.


PLINQ: Paralelismo con la Elegancia de LINQ

PLINQ (Parallel LINQ) es una versión paralela del LINQ tradicional. Basta con agregar .AsParallel() a cualquier consulta LINQ para que el runtime distribuya automáticamente el procesamiento entre los threads.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class ValidadorComPLINQ
{
    private readonly Dictionary<string, RegistroFuncionario> _indice;

    public ValidadorComPLINQ(Dictionary<string, RegistroFuncionario> indice)
    {
        _indice = indice;
    }

    public List<ResultadoCracha> ValidarTodos(IEnumerable<string> cracharIds)
    {
        return cracharIds
            .AsParallel()                           // Habilita PLINQ
            .WithDegreeOfParallelism(4)             // Limita los threads simultáneos
            .WithExecutionMode(ParallelExecutionMode.ForceParallelism) // Fuerza el paralelismo
            .Select(id =>
            {
                _indice.TryGetValue(id, out var registro);
                return ProcessarValidacao(registro, id);
            })
            .ToList();
    }
}

PLINQ con Ordenamiento

Un punto importante: PLINQ no garantiza el orden de los resultados por defecto. Si el orden importa (ej.: generar un reporte en orden de llegada), usa .AsOrdered():

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
public List<ResultadoCracha> ValidarOrdenado(IEnumerable<string> cracharIds)
{
    return cracharIds
        .AsParallel()
        .AsOrdered()               // Preserva el orden de entrada
        .WithDegreeOfParallelism(4)
        .Select(id =>
        {
            _indice.TryGetValue(id, out var registro);
            return ProcessarValidacao(registro, id);
        })
        .ToList();
}

⚠️ Atención: .AsOrdered() tiene un costo adicional de sincronización — los threads deben coordinar el orden de los resultados. Úsalo solo cuando realmente sea necesario.


Parallel.ForEachAsync — Combinando Paralelo y Asíncrono

El escenario real del torniquete es más rico: la validación involucra tanto procesamiento en memoria como consultas a la base de datos. Para eso, .NET 6+ ofrece Parallel.ForEachAsync — que combina paralelismo de CPU con operaciones asíncronas de I/O:

 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
public async Task<ResultadoValidacao> ValidarComBancoDeDadosAsync(
    IEnumerable<string> cracharIds,
    CancellationToken cancellationToken = default)
{
    var resultados = new ConcurrentBag<ResultadoCracha>();

    var opcoes = new ParallelOptions
    {
        MaxDegreeOfParallelism = 8,
        CancellationToken = cancellationToken // Propaga la cancelación
    };

    await Parallel.ForEachAsync(cracharIds, opcoes, async (id, ct) =>
    {
        // Parte asíncrona: búsqueda en la base de datos (I/O-bound)
        var registro = await _repositorio.BuscarPorCrachaAsync(id, ct);

        // Parte paralela: validación de reglas (CPU-bound)
        var resultado = ProcessarValidacao(registro, id);

        resultados.Add(resultado);
    });

    return new ResultadoValidacao(resultados.ToList());
}

Este es el patrón más poderoso: no bloquea threads durante la I/O (asíncrono) y usa múltiples núcleos para el procesamiento (paralelo).


ConcurrentDictionary: Estado Compartido sin Lock Manual

Además de ConcurrentBag, ConcurrentDictionary<TKey, TValue> es una de las estructuras más útiles en escenarios paralelos. Imagina que el torniquete necesita acumular estadísticas de acceso por sede:

 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
public class EstatisticasDeAcesso
{
    // ConcurrentDictionary: thread-safe para lectura y escritura simultáneas
    private readonly ConcurrentDictionary<string, int> _acessosPorUnidade = new();

    public void RegistrarAcesso(string unidade)
    {
        // AddOrUpdate es atómico: no necesita lock
        _acessosPorUnidade.AddOrUpdate(
            key: unidade,
            addValue: 1,
            updateValueFactory: (chave, valorAtual) => valorAtual + 1
        );
    }

    public void ProcessarEntradas(IEnumerable<EntradaFuncionario> entradas)
    {
        Parallel.ForEach(entradas, entrada =>
        {
            // Múltiples threads llamando a AddOrUpdate simultáneamente — ¡seguro!
            RegistrarAcesso(entrada.Unidade);
        });
    }

    public IReadOnlyDictionary<string, int> ObterEstatisticas()
        => _acessosPorUnidade;
}

💡 Consejo: ConcurrentDictionary es mucho más eficiente que usar un Dictionary con lock manual en escenarios de alta concurrencia de lectura/escritura, porque usa lock striping internamente — dividiendo el diccionario en segmentos independientes para minimizar la contención.


Controlando el Acceso a Recursos Limitados con SemaphoreSlim

En la vida real, los torniquetes tienen límites físicos — no puedes dejar pasar a 100 personas por la misma puerta al mismo tiempo. Lo mismo vale para el código: cuando tienes un recurso compartido limitado (conexiones a la base de datos, APIs externas, archivos), usa SemaphoreSlim para controlar el acceso concurrente:

 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
public class ValidadorComSemaforo
{
    // Limita a un máximo de 10 validaciones simultáneas en la base externa
    private readonly SemaphoreSlim _semaforo = new SemaphoreSlim(initialCount: 10, maxCount: 10);
    private readonly IRepositorioAcesso _repositorio;

    public async Task ProcessarFilaDeEntradaAsync(
        IEnumerable<string> cracharIds,
        CancellationToken ct = default)
    {
        var tasks = cracharIds.Select(async id =>
        {
            await _semaforo.WaitAsync(ct); // Espera un "lugar" en el semáforo
            try
            {
                // Solo 10 ejecuciones simultáneas llegan aquí
                var registro = await _repositorio.BuscarPorCrachaAsync(id, ct);
                return ProcessarValidacao(registro, id);
            }
            finally
            {
                _semaforo.Release(); // Libera el lugar para la próxima Task
            }
        });

        await Task.WhenAll(tasks);
    }
}

La metáfora es precisa: SemaphoreSlim es literalmente un semáforo — controla cuántos “pasos” simultáneos se permiten. WaitAsync espera un lugar; Release libera uno.


Thread Safety: Trampas Clásicas en el Paralelismo

Al paralelizar código, los errores más comunes son las race conditions — condiciones de carrera donde el resultado depende del orden impredecible de ejecución de los threads. Estos son los casos más frecuentes:

Contadores Compartidos

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
// ❌ PELIGRO: contador++ no es atómico — race condition garantizada
var totalAcessos = 0;
Parallel.ForEach(entradas, entrada =>
{
    if (ValidarAcesso(entrada))
        totalAcessos++; // Lectura + suma + escritura: 3 ops no atómicas
});

// ✅ CORRECTO: Interlocked.Increment es atómico
var totalAcessos = 0;
Parallel.ForEach(entradas, entrada =>
{
    if (ValidarAcesso(entrada))
        Interlocked.Increment(ref totalAcessos); // 1 operación atómica
});

Listas como Acumuladores

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
// ❌ PELIGRO: List<T> no es thread-safe
var aprovados = new List<string>();
Parallel.ForEach(entradas, entrada =>
{
    if (ValidarAcesso(entrada))
        aprovados.Add(entrada.Nome); // Corrupción de datos con alta concurrencia
});

// ✅ CORRECTO: usa ConcurrentBag o ConcurrentQueue
var aprovados = new ConcurrentBag<string>();
Parallel.ForEach(entradas, entrada =>
{
    if (ValidarAcesso(entrada))
        aprovados.Add(entrada.Nome); // Thread-safe
});

Acceso a Recursos Externos (Base de Datos, Archivos)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
// ❌ PELIGRO: el DbContext de EF Core no es thread-safe
var resultados = new ConcurrentBag<RegistroFuncionario>();
Parallel.ForEach(ids, id =>
{
    // DbContext compartido entre threads — excepción garantizada
    var reg = _context.Funcionarios.Find(id);
    resultados.Add(reg);
});

// ✅ CORRECTO: crea un scope por thread (patrón fábrica)
Parallel.ForEach(ids, id =>
{
    using var scope = _serviceProvider.CreateScope();
    var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
    var reg = context.Funcionarios.Find(id);
    resultados.Add(reg);
});

ℹ️ Información: El DbContext de Entity Framework Core fue diseñado para ser scoped (uno por request). Nunca compartas un único DbContext entre threads — eso causa excepciones de concurrencia y resultados incorrectos. En paralelo, crea un DbContext por iteración usando IServiceScopeFactory.


Parallel.For vs Parallel.ForEach vs PLINQ

¿Cuál usar en cada situación?

EscenarioRecomendación
Iterar una colección con índiceParallel.For(0, n, i => ...)
Iterar una colección de objetosParallel.ForEach(colecao, item => ...)
Transformar una colección (proyección)colecao.AsParallel().Select(...)
Filtrar y transformarcolecao.AsParallel().Where(...).Select(...)
Requiere I/O async + paralelismoParallel.ForEachAsync(colecao, async (item, ct) => ...)
Controlar recursos limitadosSemaphoreSlim + Task.WhenAll
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
// Parallel.For — cuando el índice importa
var resultados = new ConcurrentBag<string>();
Parallel.For(0, _registros.Count, i =>
{
    var registro = _registros[i];
    if (ValidarRegra(registro, i)) // 'i' disponible
        resultados.Add($"[{i}] {registro.Nome}");
});

// PLINQ — para pipelines de transformación complejos
var relatorio = _registros
    .AsParallel()
    .WithDegreeOfParallelism(Environment.ProcessorCount)
    .Where(r => r.Status == StatusFuncionario.Ativo)
    .Where(r => r.DataAdmissao.Year < 2020) // Empleados con más de 5 años
    .Select(r => new EntradaRelatorio(r.Nome, r.Unidade, r.CrachaId))
    .OrderBy(r => r.Unidade) // Atención: AsOrdered() implícito
    .ToList();

Ejemplo Completo: Sistema de Torniquete en Producción

Ahora armo el escenario completo con todos los patrones aprendidos — desde la carga asíncrona de la base de datos hasta la validación paralela y el reporte final:

  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
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
public class SistemaDeAcesso
{
    private readonly IRepositorioFuncionarios _repositorio;
    private readonly IServiceScopeFactory _scopeFactory;
    private Dictionary<string, RegistroFuncionario> _indiceEmMemoria = [];

    public SistemaDeAcesso(
        IRepositorioFuncionarios repositorio,
        IServiceScopeFactory scopeFactory)
    {
        _repositorio = repositorio;
        _scopeFactory = scopeFactory;
    }

    // Paso 1: Carga asíncrona de los datos (I/O-bound → async/await)
    public async Task CarregarRegistrosAsync(CancellationToken ct = default)
    {
        var registros = await _repositorio.ObterTodosAsync(ct);

        // Indexar en memoria para lookups O(1)
        _indiceEmMemoria = registros.ToDictionary(r => r.CrachaId);

        Console.WriteLine($"[Sistema] {_indiceEmMemoria.Count:N0} registros indexados.");
    }

    // Paso 2: Procesamiento paralelo (CPU-bound → Parallel)
    public RelatorioDeAcesso ProcessarLoteDeCatracas(IReadOnlyList<string> cracharIds)
    {
        var permitidos = new ConcurrentBag<string>();
        var negados = new ConcurrentBag<string>();
        var totalProcessado = 0;

        var opcoes = new ParallelOptions
        {
            MaxDegreeOfParallelism = Environment.ProcessorCount
        };

        Parallel.ForEach(cracharIds, opcoes, id =>
        {
            // Lookup O(1) en el índice en memoria
            if (_indiceEmMemoria.TryGetValue(id, out var registro)
                && registro.AcessoPermitido)
            {
                permitidos.Add(registro.NomeFuncionario);
                RegistrarEntradaLocal(registro); // Lógica CPU-bound
            }
            else
            {
                negados.Add(id);
            }

            Interlocked.Increment(ref totalProcessado);
        });

        return new RelatorioDeAcesso(
            TotalProcessado: totalProcessado,
            Permitidos: permitidos.ToList(),
            Negados: negados.ToList()
        );
    }

    // Paso 3: Persistencia asíncrona en paralelo controlado (I/O + CPU)
    public async Task SincronizarComBancoAsync(
        IEnumerable<string> cracharIds,
        CancellationToken ct = default)
    {
        // SemaphoreSlim: limita a 20 llamadas simultáneas a la base
        var semaforo = new SemaphoreSlim(20, 20);

        var tasks = cracharIds.Select(async id =>
        {
            await semaforo.WaitAsync(ct);
            try
            {
                using var scope = _scopeFactory.CreateScope();
                var context = scope.ServiceProvider
                    .GetRequiredService<AppDbContext>();

                var log = new LogAcesso
                {
                    CrachaId = id,
                    Timestamp = DateTimeOffset.UtcNow,
                    Origem = "Catraca"
                };

                context.LogsDeAcesso.Add(log);
                await context.SaveChangesAsync(ct);
            }
            finally
            {
                semaforo.Release();
            }
        });

        await Task.WhenAll(tasks);
    }

    private void RegistrarEntradaLocal(RegistroFuncionario registro)
    {
        // Operaciones locales CPU-bound (sin I/O)
        AtualizarCacheDeEntradas(registro);
        ValidarHorarioPermitido(registro);
    }
}

Cuándo NO Usar Paralelismo

El paralelismo no es una bala de plata. Hay situaciones en las que empeora el rendimiento:

1. Colecciones pequeñas: El overhead de crear y sincronizar threads puede ser mayor que el beneficio. Para menos de ~1.000 elementos simples, el código secuencial suele ser más rápido.

2. Operaciones I/O-bound simples: Si el cuello de botella es la red o el disco, agregar threads no ayuda — el bottleneck sigue siendo externo. Usa async/await.

3. Operaciones que no pueden volverse thread-safe: Si el procesamiento de cada elemento depende del resultado de los anteriores (estado compartido obligatorio), el paralelismo agrega complejidad sin beneficio.

4. Código legado con efectos secundarios ocultos: Variables globales, singletons con estado mutable, logging no thread-safe — paralelizar código así genera bugs difíciles de reproducir.

1
2
3
4
5
6
7
// ❌ No paralelizar: cada elemento depende del anterior
var soma = 0;
foreach (var valor in numeros)
    soma += valor; // Suma acumulativa: dependencia secuencial

// ✅ Usa la agregación normal de LINQ o Parallel.For con particionamiento manual
var soma = numeros.Sum(); // LINQ paralelo no ayuda aquí de todos modos

Midiendo la Diferencia: Benchmark

Para sentir la diferencia en la práctica, aquí hay un benchmark simple usando System.Diagnostics.Stopwatch:

 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
using System.Diagnostics;

var registros = GerarRegistros(80_000);
var indice = registros.ToDictionary(r => r.CrachaId);
var cracharParaValidar = GerarCrachars(2_000);

// Benchmark secuencial
var sw = Stopwatch.StartNew();
var resultadoSeq = cracharParaValidar
    .Select(id =>
    {
        indice.TryGetValue(id, out var r);
        return ProcessarValidacao(r, id);
    })
    .ToList();
sw.Stop();
Console.WriteLine($"Secuencial:  {sw.ElapsedMilliseconds}ms — {resultadoSeq.Count} elementos");

// Benchmark paralelo (PLINQ)
sw.Restart();
var resultadoPar = cracharParaValidar
    .AsParallel()
    .WithDegreeOfParallelism(Environment.ProcessorCount)
    .Select(id =>
    {
        indice.TryGetValue(id, out var r);
        return ProcessarValidacao(r, id);
    })
    .ToList();
sw.Stop();
Console.WriteLine($"PLINQ ({Environment.ProcessorCount} cores): {sw.ElapsedMilliseconds}ms — {resultadoPar.Count} elementos");

// Resultados típicos en un i7 (8 cores):
// Secuencial:          420ms — 2000 elementos
// PLINQ (8 cores):      68ms — 2000 elementos  (~6x más rápido)

💡 Consejo: Para benchmarks serios, usa la biblioteca BenchmarkDotNet — controla variables como el JIT warm-up, el GC y la varianza estadística, generando resultados mucho más confiables.


Resumen: Cuándo Usar Cada Herramienta

HerramientaMejor ParaEvitar Cuando
Parallel.ForArrays con índice, gran volumen, CPU-boundColecciones pequeñas
Parallel.ForEachColecciones de objetos, CPU-boundOperaciones con I/O pura
PLINQ (.AsParallel())Pipelines de transformación/filtroCuando el orden importa (costo)
Parallel.ForEachAsyncCPU + I/O (async dentro del paralelo)CPU pura simple
Task.WhenAll + SemaphoreSlimControlar la tasa de I/O concurrenteCPU-bound pesado
ConcurrentDictionaryEstado compartido con mucha escrituraSolo lectura (usa Dictionary)
InterlockedContadores y flags atómicosEstructuras complejas

Conclusión

El ejemplo del torniquete corporativo es perfecto para ilustrar cuándo y por qué importa el paralelismo. Una empresa centenaria no puede tener empleados esperando en la fila porque el sistema procesa una credencial a la vez. Con Parallel.ForEach, PLINQ y las colecciones concurrentes de .NET, es posible transformar procesos que tardaban cientos de milisegundos en decenas — o menos.

Los puntos fundamentales para recordar:

  • El paralelismo es para CPU-bound — cuando el procesador está trabajando, no esperando
  • Combínalo con async/await en escenarios que involucran I/O
  • Usa siempre colecciones thread-safe (ConcurrentBag, ConcurrentDictionary) para acumular resultados
  • Controla el grado de paralelismo con MaxDegreeOfParallelism — “máximo” no siempre es “mejor”
  • Usa SemaphoreSlim para proteger recursos limitados (conexiones, APIs externas)
  • Mide antes y después — el paralelismo mal aplicado puede ser más lento que el código secuencial

💡 Consejo Final: C# y el ecosistema .NET ofrecen una de las implementaciones de paralelismo más completas y mejor documentadas del mercado. La TPL (Task Parallel Library), PLINQ y las colecciones concurrentes forman parte del runtime estándar — sin dependencias externas, sin configuración adicional. Si estás construyendo sistemas que necesitan escalar, C# es una excelente elección por su madurez en este dominio. Para profundizar, explora también Channels y System.Threading.Tasks.Dataflow para pipelines de alto rendimiento.


Lee También


Referencias