Introducción a la Programación Concurrente en C# 🌐

¡Hola! Soy Diego Alejandro, y en este post de blog.codewithbotina.com, vamos a sumergirnos en el fascinante mundo de la programación concurrente. Específicamente, hablaremos de hilos (threads), thread pooling, temporizadores (timers), cronómetros (stopwatch) y cómo todo esto se relaciona con la programación concurrente en C#.

La programación concurrente es esencial en el desarrollo moderno, especialmente para aplicaciones que necesitan manejar múltiples tareas simultáneamente, como servidores web, procesamiento de datos o interfaces de usuario responsivas. Vamos a desglosar cada concepto de manera clara y con ejemplos prácticos.

¿Qué es la Programación Concurrente?

La programación concurrente se refiere a la ejecución de múltiples tareas o procesos al mismo tiempo, o al menos aparentando simultaneidad. En lugar de ejecutar código de forma secuencial (una cosa después de la otra), permitimos que varias operaciones se realicen en paralelo, lo que mejora el rendimiento y la eficiencia, especialmente en sistemas multicore.

En C#, .NET proporciona herramientas potentes para manejar concurrencia, evitando problemas como race conditions o deadlocks si se usan correctamente.

Hilos (Threads)

Un hilo es la unidad más pequeña de ejecución dentro de un proceso. Todos los programas en C# comienzan con un hilo principal, pero puedes crear hilos secundarios para tareas paralelas.

Ventajas:

• Mejora la responsividad (e.g., UI no se congela mientras se procesa data).
• Aprovecha múltiples núcleos de CPU.

Ejemplo básico en C#:

using System;
using System.Threading;

class Program {
    static void Main() {
        Thread hiloSecundario = new Thread(new ThreadStart(MetodoHilo));
        hiloSecundario.Start();
        Console.WriteLine("Este es el hilo principal.");
        hiloSecundario.Join(); // Espera a que termine el hilo secundario
    }

    static void MetodoHilo() {
        for (int i = 0; i < 5; i++) {
            Console.WriteLine($"Hilo secundario: iteración {i}");
            Thread.Sleep(500); // Simula trabajo
        }
    }
}

En este ejemplo, el hilo principal crea un hilo secundario que ejecuta un loop, mientras el principal continúa.

Cuidado: Crear muchos hilos manualmente puede ser costoso en recursos. Aquí entra el thread pooling.

Thread Pooling

El thread pooling es una técnica donde .NET mantiene un "pool" (grupo) de hilos reutilizables, gestionados por el CLR (Common Language Runtime). En lugar de crear un nuevo hilo cada vez, tomas uno del pool, lo usas y lo devuelves. Esto reduce el overhead de creación/destrucción de hilos.

Cuándo usarlo: Para tareas cortas y frecuentes, como procesamiento de solicitudes en un servidor.

Ejemplo con ThreadPool en C#:

using System;
using System.Threading;

class Program {
    static void Main() {
        ThreadPool.QueueUserWorkItem(new WaitCallback(MetodoHilo), "Dato pasado");
        Console.WriteLine("Hilo principal continúa...");
        Console.ReadLine(); // Para no cerrar la consola inmediatamente
    }

    static void MetodoHilo(object estado) {
        Console.WriteLine($"Hilo del pool: {estado}");
        // Realiza trabajo aquí
    }
}

Nota sobre Starvation: Si todos los hilos del pool están ocupados, nuevas tareas esperan, lo que se llama "thread pool starvation". Monitorea el uso para evitarlo.

Temporizadores (Timers)

Los timers permiten ejecutar código periódicamente o después de un tiempo específico. En .NET, hay varios tipos: System.Timers.Timer (para servidores), System.Threading.Timer (bajo nivel), etc.

Son útiles para tareas como actualizaciones periódicas, timeouts o scheduling.

Ejemplo con System.Timers.Timer:

using System;
using System.Timers;

class Program {
    static void Main() {
        Timer timer = new Timer(2000); // Cada 2 segundos
        timer.Elapsed += OnTimedEvent;
        timer.AutoReset = true;
        timer.Enabled = true;

        Console.WriteLine("Presiona Enter para salir.");
        Console.ReadLine();
    }

    private static void OnTimedEvent(Object source, ElapsedEventArgs e) {
        Console.WriteLine($"Evento timer: {e.SignalTime}");
    }
}

Este timer ejecuta OnTimedEvent cada 2 segundos.

Cronómetros (Stopwatch)

El Stopwatch no es para scheduling, sino para medir tiempo transcurrido con alta precisión. Es ideal para benchmarking, profiling o medir rendimiento de código.

Ejemplo en C#:

using System;
using System.Diagnostics;

class Program {
    static void Main() {
        Stopwatch sw = Stopwatch.StartNew();
        // Código a medir
        for (int i = 0; i < 1000000; i++) { /* Simula trabajo */ }
        sw.Stop();
        Console.WriteLine($"Tiempo transcurrido: {sw.ElapsedMilliseconds} ms");
    }
}

Útil para optimizar secciones de código en aplicaciones concurrentes.

Conclusión

La programación concurrente con hilos, thread pooling, timers y stopwatch en C# te permite construir aplicaciones más eficientes y escalables. Empieza con ejemplos simples y recuerda sincronizar accesos a recursos compartidos (usa locks o async/await para modernizar).

Si tienes dudas o quieres ejemplos en contextos web (como con ASP.NET), ¡comenta abajo!

Nos leemos en el próximo post 💻

¿Qué tema de concurrencia te gustaría que profundice después?

Referencias

Para este post, me basé en recursos educativos y documentación oficial. Aquí las fuentes principales:

• Hilos en C# | Multi-threading Ejemplo con Timers - YouTube
• Thread Pooling en C# | Trabajar con colecciones de hilos - YouTube
• Thread pool Starvation - NetMentor (Publicado el 7 de septiembre de 2025)
• PROGRAMACIÓN ASÍNCRONA (concurrente) / Threads CURSO en C# - YouTube
• ThreadPool - 13 - Programación Multihilos C# - YouTube
• Creating a thread - 1 - Multithreaded Programming C# - YouTube
• Uso de threads en C# | PPTX - Slideshare
• Documentación oficial de Microsoft: Threading in C# (busca en docs.microsoft.com para más detalles).