Skip to content

8. Hilos de ejecución

Este capítulo presenta la ejecución simultánea de varios fragmentos de código dentro de un mismo programa: los hilos (hilos de ejecución) y las herramientas que sirven para sincronizarlos. En 2008, la mayoría de las máquinas tenían un solo procesador, y el paralelismo era en gran medida una ilusión mantenida por el sistema operativo. Hoy en día, incluso la computadora portátil más básica tiene varios núcleos: varios hilos se ejecutan realmente al mismo tiempo, lo que hace aún más frecuentes los problemas de sincronización que se tratan aquí.

Los ejemplos son aplicaciones de un solo archivo ([dotnet run threads-01.cs]) ubicadas en la carpeta [08-threads]. Tenga en cuenta que las directivas [using] implícitas de estas aplicaciones incluyen [System.Threading] y [System.Threading.Tasks]: las clases [Thread], [Lock], [Mutex], [Monitor], [Interlocked], [Task]… pueden utilizarse sin la directiva [using].

Una advertencia antes de comenzar: los resultados de un programa multihilo varían de una ejecución a otra. El orden en que se asigna el procesador a los hilos depende del sistema operativo, del número de procesadores y de la carga de la máquina. Los resultados mostrados en este capítulo se obtuvieron en una máquina Linux de dos procesadores compartida con otros programas. Si usted ejecuta los ejemplos, obtendrá resultados similares, pero rara vez idénticos.

8.1. La clase Thread

Cuando se inicia una aplicación, se ejecuta en un flujo de ejecución llamado hilo. La clase de .NET que modela un hilo es la clase [System.Threading.Thread]. Sus principales constructores, propiedades y métodos son los siguientes:

Miembro
Función
[Thread(ThreadStart start)]
crea un hilo que ejecutará el método [start]. El delegado [ThreadStart] hace referencia a un método sin parámetros y sin valor de retorno: [void M()]
[Thread(ParameterizedThreadStart start)]
igual que el anterior, pero con un método que tiene un parámetro de tipo [object?]: [void M(object? obj)]
[static Thread CurrentThread]
el hilo que ejecuta el código que solicitó esta propiedad
[string? Name]
el nombre del hilo, útil para el seguimiento
[int ManagedThreadId]
un identificador numérico único del hilo
[bool IsBackground]
indica si el hilo es un hilo en segundo plano (véase más adelante)
[bool IsAlive]
indica si el hilo se está ejecutando actualmente
[void Start()], [void Start(object? obj)]
inicia la ejecución del hilo, pasándole opcionalmente información de tipo [object]
[void Join()], [bool Join(TimeSpan timeout)]
El hilo T1, que ejecuta [T2.Join()], se bloquea hasta que el hilo T2 haya terminado. La segunda forma limita la duración de la espera
[static void Sleep(int ms)]
El hilo que ejecuta el método se suspende durante [ms] milisegundos. Pierde la CPU, que se asigna a otro hilo

El curso de 2008 también trataba el método [Abort], que terminaba forzosamente un hilo. En la práctica ya no existe: desde .NET Core, lanza la excepción [PlatformNotSupportedException]. Detener bruscamente un hilo podía dejar los datos que manejaba en un estado inconsistente. Hoy en día, se le pide a un hilo que se detenga de manera cooperativa, mediante un token de cancelación ([CancellationToken]) que el hilo verifica regularmente: lo veremos en el próximo capítulo.

Esta es una primera aplicación que demuestra la existencia de un hilo de ejecución principal, el que ejecuta las instrucciones de nivel superior del programa (el equivalente del método [Main]). El programa [threads-01.cs] es el siguiente:

// el hilo principal de un programa

// el hilo que ejecuta este código
Thread main = Thread.CurrentThread;
// al inicio, no tiene nombre
Console.WriteLine($"Name of the current thread: [{main.Name}]");
// le damos uno
main.Name = "Main";
Console.WriteLine($"Name of the current thread: [{main.Name}]");
// algunas propiedades
Console.WriteLine($"Identifier (ManagedThreadId): {main.ManagedThreadId}");
Console.WriteLine($"Background thread (IsBackground): {main.IsBackground}");
Console.WriteLine($"Pool thread (IsThreadPoolThread): {main.IsThreadPoolThread}");
Console.WriteLine($"Priority (Priority): {main.Priority}");
Console.WriteLine($"State (ThreadState): {main.ThreadState}");
Console.WriteLine($"Number of processors: {Environment.ProcessorCount}");

// una visualización cada segundo
for (int i = 0; i < 5; i++)
{
    Console.WriteLine($"{main.Name}: {DateTime.Now:HH:mm:ss}");
    // el hilo se suspende durante 1 segundo
    Thread.Sleep(1000);
}

Resultados:

> dotnet run threads-01.cs
Name of the current thread: []
Name of the current thread: [Main]
Identifier (ManagedThreadId): 1
Background thread (IsBackground): False
Pool thread (IsThreadPoolThread): False
Priority (Priority): Normal
State (ThreadState): Running
Number of processors: 2
Main: 11:35:54
Main: 11:35:55
Main: 11:35:56
Main: 11:35:57
Main: 11:35:58

Comentarios:

  • Línea 4: se obtiene una referencia al hilo que ejecuta el programa;
  • Líneas 5–9: se muestra su nombre, se modifica y luego se vuelve a mostrar. Inicialmente, el hilo principal no tiene nombre (línea 2 de los resultados);
  • líneas 11–15: algunas propiedades del hilo. El hilo principal tiene el ID 1; es un hilo en primer plano ([IsBackground] es igual a [False]) que no pertenece a la agrupación de hilos (thread pool) (trataremos estos dos conceptos más adelante); se está ejecutando actualmente ([Running]);
  • Línea 16: la máquina que ejecutó el ejemplo tiene 2 procesadores;
  • líneas 19–23: un bucle que muestra un mensaje cada segundo. [Thread.Sleep(1000)] suspende el hilo principal durante un segundo. El curso de 2008 utilizaba aquí un bucle infinito que se terminaba con Ctrl-C; nosotros nos limitamos a cinco impresiones. Observe el formato [HH:mm:ss] (horas de 0 a 23): el curso de 2008 utilizaba [hh], que muestra las horas de 1 a 12.

8.2. Creación de hilos de ejecución

Es posible tener aplicaciones en las que fragmentos de código se ejecutan "simultáneamente" en distintos hilos de ejecución. Si la máquina tiene menos procesadores que hilos listos para ejecutarse, los hilos comparten los procesadores: cada uno utiliza un procesador por turnos durante un breve lapso (unos pocos milisegundos). En una máquina multiprocesador, varios hilos se ejecutan realmente al mismo tiempo. El tiempo asignado a un hilo depende de varios factores, entre ellos su prioridad, que tiene un valor predeterminado pero puede establecerse por programa (propiedad [Priority]). Un hilo que tiene el procesador puede liberarlo antes de tiempo:

  • al esperar un evento (la finalización de otro hilo con [Join], la espera de una señal);
  • al entrar en estado de suspensión durante un tiempo determinado ([Sleep]).

Primero se crea un hilo T con uno de los constructores presentados anteriormente, por ejemplo:

Thread t = new Thread(Display);

donde [Display] es un método con una de las dos firmas siguientes:

void Display();
void Display(object? obj);

Crear un hilo no lo inicia:

  • la ejecución del hilo T se inicia con [T.Start()]: el método pasado al constructor de T es entonces ejecutado por el hilo T. El código que ejecuta la instrucción [T.Start()] no espera a que el hilo T termine; pasa inmediatamente a la siguiente instrucción. Tenemos entonces dos hilos en ejecución paralela. A menudo necesitan comunicarse entre sí para seguir el avance del trabajo compartido: este es el problema de la sincronización de hilos;
  • Una vez iniciado, el hilo T se ejecuta de forma autónoma. Se detiene cuando el método que ejecuta termina;
  • podemos esperar a que termine de ejecutarse mediante [T.Join()]. Esta es una instrucción bloqueante: el hilo que la ejecuta se bloquea hasta que el hilo T haya terminado su trabajo. Es un método básico de sincronización.

El programa [threads-02.cs] es el siguiente:

// creación de hilos de ejecución

// damos nombre al hilo principal
Thread.CurrentThread.Name = "Main";

// creación de 5 hilos
var tasks = new Thread[5];
for (int i = 0; i < tasks.Length; i++)
{
    // el hilo n.º i ejecutará el método Display
    tasks[i] = new Thread(Display);
    // le damos un nombre
    tasks[i].Name = i.ToString();
    // iniciamos su ejecución (operación no bloqueante)
    tasks[i].Start();
}

// fin del hilo principal
Console.WriteLine($"End of thread {Thread.CurrentThread.Name} at {DateTime.Now:HH:mm:ss.fff}");

// el método ejecutado por los hilos
static void Display()
{
    // el hilo que ejecuta el método
    Thread current = Thread.CurrentThread;
    Console.WriteLine($"Start of execution of the Display method in thread {current.Name} (id {current.ManagedThreadId}): {DateTime.Now:HH:mm:ss.fff}");
    // pausa de 1 s
    Thread.Sleep(1000);
    Console.WriteLine($"End of execution of the Display method in thread {current.Name}: {DateTime.Now:HH:mm:ss.fff}");
}

Comentarios:

  • línea 4: le damos un nombre al hilo principal;
  • líneas 7–15: se crean e inician 5 hilos. Sus referencias se almacenan en un arreglo para poder recuperarlas más adelante. Cada hilo ejecuta el método [Display] de las líneas 22–29;
  • línea 11: el nombre del método [Display] se convierte automáticamente en un delegado de tipo [ThreadStart] (los delegados se introdujeron en el capítulo anterior);
  • línea 15: se lanza el hilo n.º i. Esta operación no es bloqueante: el hilo n.º i se ejecuta en paralelo con el hilo principal que lo lanzó;
  • línea 19: el hilo principal llega al final del programa;
  • líneas 22–29: el método [Display] muestra el nombre y el ID del hilo que lo ejecuta, así como las horas de inicio y de fin (al milisegundo) de la ejecución;
  • línea 28: todo hilo que ejecuta el método [Display] hace una pausa de 1 segundo. El procesador se cede entonces a otro hilo que espera el procesador. Al final de la pausa de 1 segundo, el hilo en pausa vuelve a ser elegible para obtener el procesador. Lo obtendrá cuando le llegue su turno.

Resultados:

> dotnet run threads-02.cs
Start of execution of the Display method in thread 2 (id 6): 11:36:01.725
Start of execution of the Display method in thread 4 (id 8): 11:36:01.725
End of thread Main at 11:36:01.725
Start of execution of the Display method in thread 0 (id 4): 11:36:01.725
Start of execution of the Display method in thread 1 (id 5): 11:36:01.725
Start of execution of the Display method in thread 3 (id 7): 11:36:01.725
End of execution of the Display method in thread 1: 11:36:02.779
End of execution of the Display method in thread 0: 11:36:02.778
End of execution of the Display method in thread 4: 11:36:02.779
End of execution of the Display method in thread 2: 11:36:02.779
End of execution of the Display method in thread 3: 11:36:02.779

Estos resultados son muy instructivos:

  • En primer lugar, vemos que lanzar un hilo no es bloqueante. El hilo principal lanzó 5 hilos y llegó al final del programa (línea 4) aunque tres de los hilos lanzados aún no habían mostrado su primer mensaje;
  • el orden en que se ejecutan los hilos es impredecible: en esta ejecución, los hilos 2 y 4 mostraron sus mensajes de inicio antes que el hilo 0. Aquí el sistema operativo tiene 6 hilos y 2 procesadores; asigna los procesadores a estos hilos según sus propias reglas;
  • También observamos que el orden de las impresiones no siempre sigue el orden de las horas mostradas: la hora se calcula antes de mostrarse, y mientras tanto otro hilo puede haber escrito en la consola. [Console.WriteLine] es seguro para hilos (thread-safe): dos líneas escritas por dos hilos no se mezclan, pero su orden no está garantizado;
  • cada hilo hace una pausa de un segundo con [Sleep] y luego termina de ejecutar el método [Display];
  • Por último, el programa no se detuvo cuando el hilo principal terminó su trabajo: el proceso esperó a que los 5 hilos terminaran. Esto se debe a que estos hilos son hilos en primer plano: un proceso de .NET termina cuando todos sus hilos en primer plano han terminado.

A la inversa, un hilo puede declararse como hilo en segundo plano asignando [true] a su propiedad [IsBackground] antes de lanzarlo. Los hilos en segundo plano no impiden que el proceso termine: cuando termina el último hilo en primer plano, se detienen. El programa [threads-03.cs] es el siguiente:

// hilos en segundo plano

// damos nombre al hilo principal
Thread.CurrentThread.Name = "Main";

// creación de 5 hilos en segundo plano
var tasks = new Thread[5];
for (int i = 0; i < tasks.Length; i++)
{
    tasks[i] = new Thread(Display)
    {
        Name = i.ToString(),
        // un hilo en segundo plano no impide que el proceso termine
        IsBackground = true
    };
    tasks[i].Start();
}

// damos tiempo a los hilos para que arranquen
Thread.Sleep(100);
// fin del hilo principal, y por lo tanto del proceso
Console.WriteLine($"End of thread {Thread.CurrentThread.Name} at {DateTime.Now:HH:mm:ss.fff}");

// el método ejecutado por los hilos
static void Display()
{
    Thread current = Thread.CurrentThread;
    Console.WriteLine($"Start of execution of the Display method in thread {current.Name}: {DateTime.Now:HH:mm:ss.fff}");
    // pausa de 1 s
    Thread.Sleep(1000);
    Console.WriteLine($"End of execution of the Display method in thread {current.Name}: {DateTime.Now:HH:mm:ss.fff}");
}

Comentarios:

  • línea 14: los 5 hilos son hilos en segundo plano. Las propiedades [Name] e [IsBackground] se establecen mediante un inicializador de objeto;
  • línea 20: el hilo principal espera 100 ms para darles tiempo a los hilos de iniciarse y luego termina.

Resultados:

1
2
3
4
5
6
7
> dotnet run threads-03.cs
Start of execution of the Display method in thread 4: 11:36:04.770
Start of execution of the Display method in thread 3: 11:36:04.764
Start of execution of the Display method in thread 1: 11:36:04.766
Start of execution of the Display method in thread 0: 11:36:04.764
Start of execution of the Display method in thread 2: 11:36:04.766
End of thread Main at 11:36:04.872

Los 5 hilos comenzaron su ejecución y luego el hilo principal terminó (línea 7). Los hilos en segundo plano se detuvieron entonces durante su pausa de un segundo: no se muestra ningún mensaje de fin. El curso de 2008 lograba el mismo resultado terminando [Main] con [Environment.Exit(0)], una instrucción que detiene todos los hilos de la aplicación, no solo el que la ejecuta. Los hilos de la agrupación de hilos, de los que hablaremos más adelante, son hilos en segundo plano.

Si el hilo principal desea esperar a que terminen los hilos que creó, utiliza el método [Join]. El programa [threads-04.cs] también demuestra otra forma de especificar el código que debe ejecutar un hilo: una lambda.

// espera del fin de un hilo con Join - hilos creados con una lambda

// damos nombre al hilo principal
Thread.CurrentThread.Name = "Main";

// creación de 5 hilos
var tasks = new Thread[5];
for (int i = 0; i < tasks.Length; i++)
{
    // copia local de i, capturada por la lambda
    int number = i;
    // el hilo ejecuta la lambda, que llama a Display con un parámetro con tipo
    tasks[i] = new Thread(() => Display(number, 1000 + 100 * number)) { Name = i.ToString() };
    tasks[i].Start();
}

// esperamos el fin de todos los hilos
foreach (Thread task in tasks)
{
    // el hilo principal queda bloqueado hasta el fin del hilo [task]
    task.Join();
}
// fin del hilo principal
Console.WriteLine($"End of thread {Thread.CurrentThread.Name} at {DateTime.Now:HH:mm:ss.fff}");

// el método ejecutado por los hilos
static void Display(int number, int duration)
{
    Console.WriteLine($"Start of execution of task {number} in thread {Thread.CurrentThread.Name}: {DateTime.Now:HH:mm:ss.fff}");
    // pausa de [duration] milisegundos
    Thread.Sleep(duration);
    Console.WriteLine($"End of execution of task {number} in thread {Thread.CurrentThread.Name}: {DateTime.Now:HH:mm:ss.fff}");
}

Comentarios:

  • Línea 13: el hilo ejecuta la lambda [() => Display(number, 1000 + 100 * number)]. Una lambda sin parámetros y sin valor de retorno es compatible con el delegado [ThreadStart]. Esta sintaxis permite llamar a un método con parámetros tipados (en este caso, dos [int]) en lugar de la firma impuesta [void M(object? obj)];
  • Línea 11: la lambda utiliza una copia de la variable de bucle [i]. Esto es esencial: una lambda captura la variable, no su valor. En un bucle [for], la variable [i] es única para todas las iteraciones; si la lambda utilizara [i], un hilo que arranque tarde podría leer el valor de [i] de una iteración posterior, o incluso el valor final 5. En cambio, la variable [number], declarada dentro del cuerpo del bucle, es una variable nueva en cada iteración (la variable de un bucle [foreach] también es nueva en cada iteración, a partir de C# 5);
  • líneas 18–21: el hilo principal espera a cada uno de los hilos. Primero se bloquea esperando al hilo 0, luego al hilo 1, y así sucesivamente. Al salir del bucle, los 5 hilos que lanzó han terminado;
  • línea 31: la tarea n.º i duerme 1000 + 100 × i milisegundos, de modo que los hilos terminen en un orden conocido.

Resultados:

> dotnet run threads-04.cs
Start of execution of task 1 in thread 1: 11:36:06.779
Start of execution of task 3 in thread 3: 11:36:06.779
Start of execution of task 0 in thread 0: 11:36:06.779
Start of execution of task 4 in thread 4: 11:36:06.779
Start of execution of task 2 in thread 2: 11:36:06.779
End of execution of task 0 in thread 0: 11:36:07.828
End of execution of task 1 in thread 1: 11:36:07.928
End of execution of task 2 in thread 2: 11:36:08.029
End of execution of task 3 in thread 3: 11:36:08.128
End of execution of task 4 in thread 4: 11:36:08.228
End of thread Main at 11:36:08.229

La última línea muestra que el hilo principal terminó después de los hilos que había lanzado, en el momento en que terminó el último de ellos.

8.3. Las ventajas de los hilos

Ahora que hemos puesto de relieve la existencia de un hilo predeterminado (el que ejecuta el programa principal) y sabemos cómo crear hilos adicionales, veamos las ventajas de los hilos. Tienen dos usos principales:

  • aprovechar todos los procesadores de la máquina para un cálculo que consume mucho tiempo: el trabajo se divide en fragmentos asignados a distintos hilos. Lo haremos con la biblioteca [Parallel] al final de este capítulo;
  • realizar varias tareas simultáneamente, en particular cuando algunas de ellas consisten principalmente en esperar (una respuesta de la red, una lectura de disco o una entrada del usuario). Es el caso de las aplicaciones de Internet cliente/servidor, que trataremos en un capítulo posterior.

En una aplicación de Internet cliente/servidor, un servidor ubicado en una máquina llamada S1 responde a las solicitudes de clientes ubicados en máquinas remotas C1, C2, ..., Cn:

Image

Utilizamos todos los días aplicaciones de Internet que siguen este esquema: servicios web, correo electrónico, transferencia de archivos, etc. En el diagrama anterior, el servidor S1 debe atender a los clientes Ci simultáneamente. Si tomamos el ejemplo de un servidor de archivos, sabemos que una transferencia a veces puede durar varios minutos. Es impensable que un solo cliente monopolice el servidor durante un lapso tan largo. Una solución habitual es que el servidor cree tantos hilos de ejecución como clientes haya. Cada hilo se encarga entonces de atender a un cliente específico:

Image

En la práctica, el servidor utiliza una agrupación de hilos con un número limitado de hilos, como se describe más adelante. Los servidores modernos van un paso más allá: mientras un cliente espera una respuesta de la red, no se reserva ningún hilo para él. Esto es posible gracias a la programación asíncrona, que es el tema del próximo capítulo.

8.4. Intercambio de información entre hilos

En los ejemplos anteriores, los hilos ejecutaban un método sin parámetros. El constructor [Thread(ParameterizedThreadStart)] acepta un método con la firma [void M(object? obj)]. Esto permite pasar información al hilo lanzado:

t.Start(obj1);

lanza el hilo [t], que ejecuta entonces el método asociado a él por construcción, pasándole el parámetro real [obj1]. El programa [threads-05.cs] es el siguiente:

// intercambio de información entre hilos

// damos nombre al hilo principal
Thread.CurrentThread.Name = "Main";

// creación de 5 hilos
var tasks = new Thread[5];
var data = new Data[5];
for (int i = 0; i < tasks.Length; i++)
{
    // el hilo n.º i ejecutará el método Sleep(object?)
    tasks[i] = new Thread(Sleep) { Name = i.ToString() };
    // el objeto intercambiado con el hilo: el hilo lanzador fija Start y Duration
    data[i] = new Data { Start = DateTime.Now, Duration = i + 1 };
    // iniciamos el hilo pasándole este objeto
    tasks[i].Start(data[i]);
}

// esperamos los hilos uno tras otro
for (int i = 0; i < tasks.Length; i++)
{
    // espera del fin del hilo n.º i
    tasks[i].Join();
    // el hilo n.º i ha completado la propiedad End de su objeto
    Data d = data[i];
    Console.WriteLine($"Thread {tasks[i].Name} finished: start {d.Start:HH:mm:ss}, scheduled duration {d.Duration} s, end {d.End:HH:mm:ss}, actual duration {(d.End - d.Start).TotalSeconds:F3} s");
}
// fin del hilo principal
Console.WriteLine($"End of thread {Thread.CurrentThread.Name} at {DateTime.Now:HH:mm:ss}");

// el método ejecutado por los hilos: firma void (object?)
static void Sleep(object? state)
{
    // recuperamos el parámetro con su tipo real
    if (state is not Data info)
    {
        return;
    }
    // pausa de Duration segundos
    Thread.Sleep(info.Duration * 1000);
    // el hilo lanzado devuelve un resultado al hilo lanzador
    info.End = DateTime.Now;
}

// la información intercambiada entre el hilo lanzador y el hilo lanzado
class Data
{
    // fijado por el hilo lanzador
    public DateTime Start { get; init; }
    public int Duration { get; init; }
    // fijado por el hilo lanzado
    public DateTime End { get; set; }
}

Comentarios:

  • Líneas 46–52: la información pasada a los hilos es un objeto [Data]. Hay un intercambio bidireccional de información entre el hilo que lanza y el hilo lanzado. [Start] y [Duration] son propiedades [init]: solo pueden establecerse al crear el objeto:
    • [Start]: la hora de inicio de la ejecución del hilo, establecida por el hilo que lanza;
    • [Duration]: duración en segundos de la pausa del hilo lanzado, establecida por el hilo que lanza;
    • [End]: la hora de fin de la ejecución del hilo, establecida por el hilo lanzado;
  • línea 12: cada hilo se asocia al método [Sleep] de las líneas 32–42, cuya firma [void Sleep(object? state)] corresponde al delegado [ParameterizedThreadStart];
  • líneas 14–16: se crea un objeto [Data], se almacena en el arreglo [data] y luego se pasa al método [Start], que lanza el hilo;
  • líneas 20–26: el hilo principal espera a que termine cada uno de los hilos que lanzó, luego recupera el objeto [data[i]] del hilo n.º i y muestra su contenido;
  • línea 35: el parámetro recibido es de tipo [object?]; el filtro por patrón [state is not Data info] verifica su tipo real y lo almacena en la variable tipada [info]. El curso de 2008 realizaba una conversión de tipo (cast) a [(Data)state], que lanza una excepción si el objeto no es del tipo esperado;
  • línea 40: la propiedad [Duration] del parámetro establece la duración de la pausa;
  • línea 42: se establece la propiedad [End] del parámetro.

Resultados:

1
2
3
4
5
6
7
> dotnet run threads-05.cs
Thread 0 finished: start 11:36:10, scheduled duration 1 s, end 11:36:11, actual duration 1.044 s
Thread 1 finished: start 11:36:10, scheduled duration 2 s, end 11:36:12, actual duration 2.000 s
Thread 2 finished: start 11:36:10, scheduled duration 3 s, end 11:36:13, actual duration 3.000 s
Thread 3 finished: start 11:36:10, scheduled duration 4 s, end 11:36:14, actual duration 4.000 s
Thread 4 finished: start 11:36:10, scheduled duration 5 s, end 11:36:15, actual duration 5.000 s
End of thread Main at 11:36:15

Este ejemplo muestra que dos hilos pueden intercambiar información:

  • el hilo que llama puede controlar la ejecución del hilo llamado proporcionándole información;
  • el hilo lanzado puede devolver resultados al hilo que lo lanzó.

Para que el hilo que llama sepa cuándo están disponibles los resultados que espera, debe ser notificado cuando el hilo llamado haya terminado. Aquí, esperó a que el hilo llamado terminara mediante el método [Join]. [Join] también garantiza que cualquier escritura realizada por el hilo llamado sea visible para el hilo que lo espera. Más adelante veremos otras formas de sincronizar.

Con una lambda, ya no es necesario utilizar el tipo [object]: la lambda captura directamente variables tipadas. Las líneas 12–16 podrían escribirse de la siguiente manera:

1
2
3
4
Data d = new() { Start = DateTime.Now, Duration = i + 1 };
data[i] = d;
tasks[i] = new Thread(() => Sleep(d)) { Name = i.ToString() };
tasks[i].Start();

con un método [static void Sleep(Data data)] que ya no necesita verificar el tipo de su parámetro. Este es el enfoque más habitual hoy en día.

8.5. Acceso concurrente a recursos compartidos

8.5.1. Acceso concurrente no sincronizado

En el apartado anterior, la información se intercambiaba solo entre dos hilos y en momentos muy precisos: era un ejemplo clásico de paso de parámetros. Hay otros casos en los que la información es compartida por varios hilos que pueden querer leerla o actualizarla al mismo tiempo. Esto plantea el problema de la integridad de esa información. Supongamos que la información compartida es una estructura S que contiene diversos datos I1, I2, ..., In:

  • un hilo T1 comienza a actualizar la estructura S: modifica el campo I1 y es interrumpido antes de completar la actualización de la estructura S;
  • un hilo T2 que obtiene el procesador lee entonces la estructura S para tomar decisiones. Lee una estructura en un estado inestable: algunos campos están actualizados y otros no.

Esta situación se denomina acceso concurrente a un recurso compartido, en este caso la estructura S. A menudo es difícil de gestionar. Consideremos el siguiente ejemplo para ilustrar los problemas que pueden surgir:

  • una aplicación generará n hilos, donde n se pasa como parámetro;
  • el recurso compartido es un contador que debe ser incrementado por cada hilo generado;
  • al final de la aplicación, se muestra el valor del contador. Por lo tanto, debería ser igual a n.

El programa [threads-06.cs] es el siguiente:

// acceso concurrente no sincronizado a un recurso compartido

// verificación del argumento: el número de hilos por crear
const int nbMaxThreads = 100;
if (args.Length != 1 || !int.TryParse(args[0], out int nbThreads) || nbThreads is < 1 or > nbMaxThreads)
{
    Console.Error.WriteLine($"syntax: dotnet run threads-06.cs -- nbThreads (nbThreads between 1 and {nbMaxThreads})");
    return 1;
}

// creación e inicio de los hilos
var threads = new Thread[nbThreads];
for (int i = 0; i < nbThreads; i++)
{
    threads[i] = new Thread(Counter.Increment) { Name = i.ToString() };
    threads[i].Start();
}
// espera del fin de los hilos
foreach (Thread thread in threads)
{
    thread.Join();
}
// visualización del contador
Console.WriteLine($"Number of threads generated: {Counter.Value}");
return 0;

// el recurso compartido
static class Counter
{
    // el contador de hilos, compartido por todos los hilos
    public static int Value { get; private set; }

    // el método ejecutado por cada hilo
    public static void Increment()
    {
        // lectura del contador
        int value = Value;
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {Thread.CurrentThread.Name} read the counter value: {value}");
        // espera: el hilo pierde el procesador
        Thread.Sleep(1000);
        // incremento del contador
        Value = value + 1;
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {Thread.CurrentThread.Name} wrote the counter value: {Value}");
    }
}

Comentarios:

  • Líneas 4–8: el número de hilos se pasa como argumento. La condición de la línea 5 combina todas las verificaciones: se requiere un argumento; debe ser un entero ([int.TryParse]); y debe estar entre 1 y 100 (patrón relacional [nbThreads is < 1 or > nbMaxThreads]). El programa devuelve un código de salida 1 si se produce un error, 0 en caso contrario (línea 25);
  • líneas 28–43: el recurso compartido es la propiedad estática [Counter.Value]. El contador está encapsulado en una clase estática, con el método [Increment] ejecutado por cada hilo. Una instrucción de nivel superior no puede declarar un campo: por lo tanto, los datos compartidos por los hilos son miembros estáticos de una clase;
  • línea 37: se lee el contador;
  • línea 40: el hilo hace una pausa de 1 segundo. Por lo tanto, pierde la CPU;
  • línea 42: se incrementa el contador.

La pausa de un segundo está ahí solo para obligar al hilo a perder el procesador entre la lectura y la escritura del contador. En la práctica, no hay ninguna garantía de que un hilo no sea interrumpido entre esos dos momentos, y en una máquina multiprocesador, dos hilos incluso pueden leer el contador exactamente al mismo tiempo. La pausa de un segundo se limita a sistematizar este riesgo.

Para pasar argumentos a una aplicación de un solo archivo, colóquelos después de [--]:

> dotnet run threads-06.cs -- 5
At 11:36:17.169, thread 3 read the counter value: 0
At 11:36:17.169, thread 4 read the counter value: 0
At 11:36:17.169, thread 2 read the counter value: 0
At 11:36:17.169, thread 0 read the counter value: 0
At 11:36:17.169, thread 1 read the counter value: 0
At 11:36:18.216, thread 3 wrote the counter value: 1
At 11:36:18.216, thread 4 wrote the counter value: 1
At 11:36:18.217, thread 2 wrote the counter value: 1
At 11:36:18.217, thread 1 wrote the counter value: 1
At 11:36:18.217, thread 0 wrote the counter value: 1
Number of threads generated: 1

Al observar estos resultados, se ve claramente lo que ocurre:

  • Un primer hilo lee el contador. Encuentra 0. Hace una pausa de 1 segundo y pierde así la CPU;
  • un segundo hilo también lee el valor del contador. Sigue siendo 0, ya que el hilo anterior aún no lo ha incrementado. También hace una pausa de 1 segundo;
  • en menos de un segundo, los 5 hilos tienen tiempo de leer el valor 0;
  • al despertar, incrementan el valor 0 que leyeron y todos escriben el valor 1 en el contador, como confirma la última línea (línea 12).

Se podría objetar que el ejemplo es artificial. Quitemos entonces el [Sleep] y utilicemos el operador [++], que da la ilusión de una sola instrucción. El programa [threads-07.cs] es el siguiente:

// actualizaciones perdidas sin Sleep: counter++ no es atómico

// parámetros: número de hilos, número de incrementos por hilo
int nbThreads = args.Length > 0 && int.TryParse(args[0], out int n) ? n : 4;
int nbIncrements = args.Length > 1 && int.TryParse(args[1], out int m) ? m : 50_000_000;

// repetimos el experimento tres veces
for (int attempt = 1; attempt <= 3; attempt++)
{
    Counter.Value = 0;
    // creación e inicio de los hilos
    var threads = new Thread[nbThreads];
    for (int i = 0; i < nbThreads; i++)
    {
        threads[i] = new Thread(() =>
        {
            for (int j = 0; j < nbIncrements; j++)
            {
                // leer, incrementar, escribir: tres operaciones
                Counter.Value++;
            }
        });
        threads[i].Start();
    }
    // espera del fin de los hilos
    foreach (Thread thread in threads)
    {
        thread.Join();
    }
    // resultado
    int expected = nbThreads * nbIncrements;
    Console.WriteLine($"Attempt {attempt}: expected value {expected:N0}, obtained value {Counter.Value:N0}, lost updates {expected - Counter.Value:N0}");
}

// el recurso compartido
static class Counter
{
    public static int Value;
}

Comentarios:

  • Líneas 4–5: el número de hilos (4 de forma predeterminada) y el número de incrementos que realiza cada hilo (50 millones de forma predeterminada) pueden pasarse como argumentos. La expresión [args.Length > 0 && int.TryParse(args[0], out int n) ? n : 4] devuelve el argumento si existe y es válido; de lo contrario, devuelve el valor predeterminado. El separador [_] hace legible la constante [50_000_000];
  • línea 20: cada hilo incrementa el contador compartido sin ninguna pausa;
  • línea 38: esta vez, el contador es un campo;
  • línea 32: el formato [N0] muestra un entero con separador de miles.

Resultados:

1
2
3
4
> dotnet run threads-07.cs
Attempt 1: expected value 200,000,000, obtained value 120,818,197, lost updates 79,181,803
Attempt 2: expected value 200,000,000, obtained value 121,419,329, lost updates 78,580,671
Attempt 3: expected value 200,000,000, obtained value 114,583,348, lost updates 85,416,652

Se perdieron decenas de millones de actualizaciones, y el número varía de una prueba a otra. La operación de alto nivel [Counter.Value++] se traduce en realidad en varias instrucciones básicas del procesador: leer el valor de la memoria, incrementarlo en un registro y escribir el resultado en la memoria. Si dos hilos leen el mismo valor antes de que uno de ellos haya escrito el suyo, se pierde un incremento, exactamente como en el ejemplo anterior. Se necesitan muchas iteraciones para observarlo: con un millón de incrementos por hilo, cada hilo suele haber terminado su trabajo antes de que el siguiente haya comenzado, y el resultado es correcto. Esto es lo que hace tan peligrosos estos errores: un programa puede funcionar durante meses y fallar justo el día en que el sistema soporta una carga mayor.

¿De dónde proviene el problema? Un hilo leyó un valor desactualizado porque otro hilo había sido interrumpido (o trabajaba simultáneamente en otro procesador) antes de terminar su tarea de actualizar el contador. Esto nos lleva a los conceptos de recurso crítico y sección crítica en un programa:

  • un recurso crítico es un recurso que solo puede ser mantenido por un hilo a la vez. Aquí, el recurso crítico es el contador;
  • una sección crítica de un programa es una secuencia de instrucciones del flujo de ejecución de un hilo durante la cual accede a un recurso crítico. Debemos asegurarnos de que, durante esta sección crítica, el hilo sea el único con acceso al recurso.

En el programa [threads-06.cs], la sección crítica es el código comprendido entre la lectura del contador y la escritura de su nuevo valor:

1
2
3
4
5
6
// lectura del contador
int value = Value;
// espera: el hilo pierde el procesador
Thread.Sleep(1000);
// incremento del contador
Value = value + 1;

Para ejecutar este código, se debe garantizar que un hilo sea el único en ejecución. Puede ser interrumpido, pero durante esa interrupción ningún otro hilo debe poder ejecutar este mismo código. La plataforma .NET ofrece diversas herramientas para garantizar el acceso exclusivo a las secciones críticas de código. Veremos algunas de ellas a continuación.

8.5.2. La cláusula [lock] y el tipo [Lock]

La cláusula [lock] delimita una sección crítica de la siguiente manera:

1
2
3
4
lock (padlock)
{
    // sección crítica
}

[padlock] es un objeto visible para todos los hilos que ejecutan la sección crítica. La cláusula [lock] garantiza que un solo hilo a la vez ejecute la sección crítica: un hilo que encuentra un cerrojo en poder de otro hilo se bloquea hasta que el cerrojo se libere.

A partir de C# 13 y .NET 9, el objeto de sincronización debería ser preferentemente una instancia del tipo [System.Threading.Lock], diseñado para este fin. El ejemplo anterior se reescribe de la siguiente manera en [threads-08.cs]:

// sección crítica protegida por la cláusula lock y el tipo System.Threading.Lock (C# 13 / .NET 9)

// verificación del argumento: el número de hilos por crear
const int nbMaxThreads = 100;
if (args.Length != 1 || !int.TryParse(args[0], out int nbThreads) || nbThreads is < 1 or > nbMaxThreads)
{
    Console.Error.WriteLine($"syntax: dotnet run threads-08.cs -- nbThreads (nbThreads between 1 and {nbMaxThreads})");
    return 1;
}

// creación e inicio de los hilos
var threads = new Thread[nbThreads];
for (int i = 0; i < nbThreads; i++)
{
    threads[i] = new Thread(Counter.Increment) { Name = i.ToString() };
    threads[i].Start();
}
// espera del fin de los hilos, en el orden inverso al de su creación
Thread.CurrentThread.Name = "Main";
for (int i = nbThreads - 1; i >= 0; i--)
{
    Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread Main waits for the end of thread {threads[i].Name}");
    threads[i].Join();
    Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread Main was notified of the end of thread {threads[i].Name}");
}
// visualización del contador
Console.WriteLine($"Number of threads generated: {Counter.Value}");
return 0;

// el recurso compartido
static class Counter
{
    // el contador de hilos
    public static int Value { get; private set; }
    // el objeto de sincronización, visible para todos los hilos
    private static readonly Lock padlock = new();

    // el método ejecutado por cada hilo
    public static void Increment()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} waits for permission to enter the critical section");
        // solo un hilo a la vez ejecuta el bloque siguiente
        lock (padlock)
        {
            // lectura del contador
            int value = Value;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} read the counter value: {value}");
            // espera: el hilo pierde el procesador pero conserva el lock
            Thread.Sleep(1000);
            // incremento del contador
            Value = value + 1;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} wrote the counter value: {Value}");
        }
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} left the critical section");
    }
}

Comentarios:

  • línea 36: [padlock] es el objeto que permitirá sincronizar todos los hilos. Es [readonly]: la referencia nunca debe cambiar; de lo contrario, dos hilos podrían bloquear dos objetos distintos;
  • Líneas 44–53: la sección crítica del método [Increment] está encerrada por la cláusula [lock]. El hilo mantiene el cerrojo mientras duerme durante un segundo: los demás hilos no pueden entrar;
  • Líneas 20–24: el hilo principal espera a los hilos en el orden inverso al de su creación.

Resultados con 3 hilos:

> dotnet run threads-08.cs -- 3
At 11:36:23.809, thread Main waits for the end of thread 2
At 11:36:23.809, thread 0 waits for permission to enter the critical section
At 11:36:23.809, thread 1 waits for permission to enter the critical section
At 11:36:23.809, thread 2 waits for permission to enter the critical section
At 11:36:23.855, thread 0 read the counter value: 0
At 11:36:24.855, thread 0 wrote the counter value: 1
At 11:36:24.856, thread 1 read the counter value: 1
At 11:36:24.856, thread 0 left the critical section
At 11:36:25.856, thread 1 wrote the counter value: 2
At 11:36:25.856, thread 1 left the critical section
At 11:36:25.856, thread 2 read the counter value: 2
At 11:36:26.856, thread 2 wrote the counter value: 3
At 11:36:26.856, thread 2 left the critical section
At 11:36:26.857, thread Main was notified of the end of thread 2
At 11:36:26.857, thread Main waits for the end of thread 1
At 11:36:26.857, thread Main was notified of the end of thread 1
At 11:36:26.857, thread Main waits for the end of thread 0
At 11:36:26.857, thread Main was notified of the end of thread 0
Number of threads generated: 3
  • Los tres hilos solicitan entrar en la sección crítica casi al mismo tiempo;
  • solo uno entra: en este caso, el hilo 0 (el orden de entrada no está garantizado: no es necesariamente el primero en llegar el que entra primero). Lee el contador, duerme durante un segundo, escribe el nuevo valor y sale de la sección crítica;
  • los otros dos hilos permanecen bloqueados hasta que el primero sale de la sección crítica, y luego avanzan uno tras otro. Cada uno lee el valor escrito por el anterior;
  • el hilo principal esperaba a que terminara el hilo 2. Cuando es notificado, espera a que termine el hilo 1, que ya había terminado: es notificado de inmediato. Lo mismo ocurre con el hilo 0;
  • el número de hilos es correcto (línea 20).

El compilador traduce la cláusula [lock (padlock) { ... }] sobre un objeto [Lock] como:

1
2
3
4
using (padlock.EnterScope())
{
    // sección crítica
}

[EnterScope] adquiere el cerrojo y devuelve una estructura cuyo método [Dispose], invocado al salir del bloque [using], libera el cerrojo, incluso si la sección crítica lanza una excepción. El tipo [Lock] también ofrece los métodos [Enter], [TryEnter], y [Exit] para los casos en que el cerrojo no puede gestionarse mediante un bloque.

Antes de .NET 9, y en mucho código existente, el cerrojo era un objeto genérico, normalmente de tipo [object]:

1
2
3
4
5
6
private static readonly object synchro = new();
...
lock (synchro)
{
    // sección crítica
}

Esta forma sigue siendo válida: cualquier objeto de .NET puede servir como cerrojo. El compilador la traduce entonces a llamadas a la clase [Monitor], que examinaremos más adelante:

bool lockTaken = false;
try
{
    Monitor.Enter(synchro, ref lockTaken);
    // sección crítica
}
finally
{
    if (lockTaken) Monitor.Exit(synchro);
}

El tipo [Lock] es más eficiente y hace explícita la intención. Siempre se bloquea un objeto privado: bloquear un objeto visible externamente ([this], un tipo con [typeof(...)], una cadena) permitiría que código externo adquiriera el mismo cerrojo y bloqueara el nuestro.

8.5.3. La clase Mutex

La clase [System.Threading.Mutex] también permite delimitar secciones críticas. Se diferencia de la cláusula [lock] en cuanto a su visibilidad:

  • la cláusula [lock] sincroniza hilos dentro de la misma aplicación;
  • la clase [Mutex] puede sincronizar hilos de distintas aplicaciones (o procesos) si se le asigna un nombre.

Un [Mutex] es un objeto del sistema operativo: su uso consume muchos más recursos que el de un [lock]. Para hilos del mismo proceso, preferimos por lo tanto utilizar [lock]; [Mutex] se utiliza principalmente entre procesos. Utilizaremos los siguientes constructores y métodos:

Miembro
Función
[Mutex()]
crea un Mutex M anónimo, utilizable por los hilos del proceso
[Mutex(bool initiallyOwned, string name)]
crea o abre el mutex con nombre [name], compartido por todos los procesos que usan este nombre
[bool WaitOne()]
El hilo T1, que ejecuta [M.WaitOne()], solicita la propiedad del mutex M. Si M no está en poder de ningún hilo, se le concede a T1. Si un hilo T2 intenta entonces la misma operación, se bloquea: un mutex solo puede pertenecer a un hilo. T2 se desbloqueará cuando T1 libere M. Así, varios hilos pueden quedar bloqueados a la espera de M
[bool WaitOne(TimeSpan timeout)]
Igual que el anterior, pero la espera se limita a [timeout]. El método devuelve [false] si no se pudo adquirir el mutex
[void ReleaseMutex()]
El hilo que posee M lo libera. Uno de los hilos que esperan M lo adquiere entonces

La sincronización de una sección crítica se realiza de la siguiente manera:

1
2
3
4
5
6
7
8
9
M.WaitOne();
try
{
    // el hilo es el único que entra aquí: sección crítica
}
finally
{
    M.ReleaseMutex();
}

No olvide liberar un mutex; de lo contrario, los hilos que lo esperan permanecerán bloqueados indefinidamente. Por eso la liberación se realiza en una instrucción [finally], que se ejecuta independientemente de que se haya producido una excepción. El programa [threads-09.cs] retoma el ejemplo anterior utilizando un mutex:

// sección crítica protegida por un Mutex

// verificación del argumento: el número de hilos por crear
const int nbMaxThreads = 100;
if (args.Length != 1 || !int.TryParse(args[0], out int nbThreads) || nbThreads is < 1 or > nbMaxThreads)
{
    Console.Error.WriteLine($"syntax: dotnet run threads-09.cs -- nbThreads (nbThreads between 1 and {nbMaxThreads})");
    return 1;
}

// creación e inicio de los hilos
var threads = new Thread[nbThreads];
for (int i = 0; i < nbThreads; i++)
{
    threads[i] = new Thread(Counter.Increment) { Name = i.ToString() };
    threads[i].Start();
}
// espera del fin de los hilos
foreach (Thread thread in threads)
{
    thread.Join();
}
// visualización del contador
Console.WriteLine($"Number of threads generated: {Counter.Value}");
return 0;

// el recurso compartido
static class Counter
{
    // el contador de hilos
    public static int Value { get; private set; }
    // el objeto de sincronización: un Mutex
    private static readonly Mutex synchro = new();

    // el método ejecutado por cada hilo
    public static void Increment()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} waits for permission to enter the critical section");
        // solicitamos la propiedad del Mutex
        synchro.WaitOne();
        try
        {
            // lectura del contador
            int value = Value;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} read the counter value: {value}");
            // espera
            Thread.Sleep(1000);
            // incremento del contador
            Value = value + 1;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} wrote the counter value: {Value}");
        }
        finally
        {
            // liberamos el Mutex, haya o no excepción
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} leaves the critical section");
            synchro.ReleaseMutex();
        }
    }
}

Comentarios:

  • línea 33: el objeto de sincronización de hilos es ahora un mutex;
  • línea 41: inicio de la sección crítica. El hilo se bloquea hasta que el mutex esté libre;
  • líneas 42–57: como un mutex siempre debe liberarse, se produzca o no una excepción, la sección crítica se coloca dentro de un [try], cuya cláusula [finally] libera el mutex (línea 57).

Resultados:

> dotnet run threads-09.cs -- 3
At 11:36:28.858, thread 2 waits for permission to enter the critical section
At 11:36:28.906, thread 2 read the counter value: 0
At 11:36:28.858, thread 0 waits for permission to enter the critical section
At 11:36:28.858, thread 1 waits for permission to enter the critical section
At 11:36:29.907, thread 2 wrote the counter value: 1
At 11:36:29.907, thread 2 leaves the critical section
At 11:36:29.907, thread 0 read the counter value: 1
At 11:36:30.907, thread 0 wrote the counter value: 2
At 11:36:30.907, thread 0 leaves the critical section
At 11:36:30.907, thread 1 read the counter value: 2
At 11:36:31.908, thread 1 wrote the counter value: 3
At 11:36:31.908, thread 1 leaves the critical section
Number of threads generated: 3

Los resultados son similares a los anteriores: los hilos pasan por la sección crítica uno por uno y el valor final del contador es correcto.

El verdadero valor del mutex se aprecia con un mutex con nombre. El programa [threads-10.cs] se ejecuta dos veces, en dos procesos distintos, que comparten una sección crítica:

// un Mutex con nombre sincroniza hilos de procesos diferentes

// el nombre del Mutex es conocido por todos los procesos que lo usan
const string mutexName = @"Global\csharp-course-threads-10";
// el nombre del proceso se pasa como argumento
string process = args.Length > 0 ? args[0] : "P";

// abrimos el Mutex con nombre (se crea si aún no existe)
using var mutex = new Mutex(false, mutexName);
Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: process {process} requests the Mutex");
// intento sin espera
if (!mutex.WaitOne(TimeSpan.Zero))
{
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: the Mutex is held by another process, {process} waits");
    // espera sin límite de tiempo
    mutex.WaitOne();
}
try
{
    // sección crítica entre procesos
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: process {process} obtained the Mutex, it works for 3 s");
    Thread.Sleep(3000);
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: process {process} releases the Mutex");
}
finally
{
    mutex.ReleaseMutex();
}

Comentarios:

  • Línea 4: el nombre del mutex. Todos los procesos que abren un mutex con este nombre utilizan el mismo objeto del sistema. El prefijo [Global] especifica que el mutex es visible para todas las sesiones de la máquina (el prefijo predeterminado [Local] lo limita a la sesión del usuario);
  • Línea 9: el mutex con nombre se crea si aún no existe; de lo contrario, se abre. El primer parámetro, [false], indica que el proceso no solicita su propiedad al crearlo. La declaración [using] libera el objeto [Mutex] al final del programa;
  • línea 12: el proceso intenta adquirir el mutex de inmediato ([TimeSpan.Zero]). Si falla, informa del fallo y luego lo espera indefinidamente (línea 16);
  • Líneas 18–27: la sección crítica, que dura 3 segundos, seguida de la liberación del mutex.

El script de captura lanza el proceso A, espera 1,5 segundos y luego lanza el proceso B. Resultados del proceso A:

1
2
3
4
> dotnet run threads-10.cs -- A
11:36:35.438: process A requests the Mutex
11:36:35.486: process A obtained the Mutex, it works for 3 s
11:36:38.487: process A releases the Mutex

Resultados del proceso B:

1
2
3
4
5
> dotnet run threads-10.cs -- B
11:36:36.908: process B requests the Mutex
11:36:36.957: the Mutex is held by another process, B waits
11:36:38.487: process B obtained the Mutex, it works for 3 s
11:36:41.487: process B releases the Mutex

El proceso B encontró el mutex en poder del proceso A y esperó. Lo adquirió en el mismo instante en que A lo liberó. Un uso habitual de un mutex con nombre es impedir que se inicien dos instancias de la misma aplicación: la segunda instancia, al no poder adquirir el mutex, termina de inmediato. Si un proceso termina sin liberar un mutex que posee, se dice que el mutex está abandonado: el siguiente proceso que llame a [WaitOne] lo adquiere, pero lanza la excepción [AbandonedMutexException] para indicar que el recurso protegido puede estar en un estado inconsistente.

8.5.4. La clase AutoResetEvent

Un objeto [AutoResetEvent] es una barrera que deja pasar un solo hilo a la vez. Se construye de la siguiente manera:

AutoResetEvent barrier = new AutoResetEvent(state);

El booleano [state] indica si la barrera está cerrada ([false]) o abierta ([true]). Un hilo que desea atravesar la barrera lo indica de la siguiente manera:

barrier.WaitOne();
  • Si la barrera está abierta, el hilo pasa y la barrera se cierra automáticamente tras él (de ahí el nombre de la clase). Si varios hilos esperan, solo uno pasa;
  • si la barrera está cerrada, el hilo se bloquea. Otro hilo la abrirá cuando llegue el momento. Ese momento depende por completo del problema que se resuelve. La barrera se abre mediante la operación:
barrier.Set();

Un hilo también puede cerrar una barrera con [barrier.Reset()]. A diferencia de un mutex, una barrera no pertenece a ningún hilo en particular: cualquier hilo puede abrirla. Si, en el ejemplo anterior, reemplazamos el mutex por un [AutoResetEvent], el código queda de la siguiente manera [threads-11.cs]:

// sección crítica protegida por una barrera AutoResetEvent

// verificación del argumento: el número de hilos por crear
const int nbMaxThreads = 100;
if (args.Length != 1 || !int.TryParse(args[0], out int nbThreads) || nbThreads is < 1 or > nbMaxThreads)
{
    Console.Error.WriteLine($"syntax: dotnet run threads-11.cs -- nbThreads (nbThreads between 1 and {nbMaxThreads})");
    return 1;
}

// creación e inicio de los hilos
var threads = new Thread[nbThreads];
for (int i = 0; i < nbThreads; i++)
{
    threads[i] = new Thread(Counter.Increment) { Name = i.ToString() };
    threads[i].Start();
}
// dejamos que los hilos lleguen a la barrera cerrada
Thread.Sleep(500);
// abrimos la barrera de la sección crítica
Thread.CurrentThread.Name = "Main";
Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread Main opens the barrier of the critical section");
Counter.Synchro.Set();
// espera del fin de los hilos
foreach (Thread thread in threads)
{
    thread.Join();
}
// visualización del contador
Console.WriteLine($"Number of threads generated: {Counter.Value}");
return 0;

// el recurso compartido
static class Counter
{
    // el contador de hilos
    public static int Value { get; private set; }
    // la barrera, creada cerrada (false)
    public static readonly AutoResetEvent Synchro = new(false);

    // el método ejecutado por cada hilo
    public static void Increment()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} waits for permission to enter the critical section");
        // paso de la barrera: se vuelve a cerrar detrás del hilo
        Synchro.WaitOne();
        try
        {
            // lectura del contador
            int value = Value;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} read the counter value: {value}");
            // espera
            Thread.Sleep(1000);
            // incremento del contador
            Value = value + 1;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} wrote the counter value: {Value}");
        }
        finally
        {
            // volvemos a abrir la barrera para otro hilo
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} leaves the critical section");
            Synchro.Set();
        }
    }
}

Comentarios:

  • línea 39: la barrera se crea en estado cerrado. Será abierta por el hilo principal en la línea 23;
  • línea 19: el hilo principal espera medio segundo para permitir que los hilos lleguen a la barrera;
  • línea 47: el hilo encargado de incrementar el contador solicita permiso para entrar en la sección crítica. Los distintos hilos se acumulan frente a la barrera cerrada. Cuando el hilo principal la abre, uno de los hilos en espera pasa y la barrera se cierra de nuevo;
  • línea 63: cuando ha terminado su trabajo, el hilo vuelve a abrir la barrera, permitiendo que entre otro hilo.

Resultados:

> dotnet run threads-11.cs -- 3
At 11:36:43.413, thread 2 waits for permission to enter the critical section
At 11:36:43.407, thread 0 waits for permission to enter the critical section
At 11:36:43.411, thread 1 waits for permission to enter the critical section
At 11:36:43.914, thread Main opens the barrier of the critical section
At 11:36:43.915, thread 2 read the counter value: 0
At 11:36:44.915, thread 2 wrote the counter value: 1
At 11:36:44.915, thread 2 leaves the critical section
At 11:36:44.915, thread 0 read the counter value: 1
At 11:36:45.916, thread 0 wrote the counter value: 2
At 11:36:45.916, thread 0 leaves the critical section
At 11:36:45.916, thread 1 read the counter value: 2
At 11:36:46.916, thread 1 wrote the counter value: 3
At 11:36:46.916, thread 1 leaves the critical section
Number of threads generated: 3

Los resultados son similares a los anteriores. Vemos que los tres hilos esperan frente a la barrera hasta que el hilo principal la abre (línea 5).

8.5.5. Las clases ManualResetEventSlim y SemaphoreSlim

Otras dos herramientas de sincronización complementan las anteriores.

Un objeto [ManualResetEventSlim] es una barrera que, una vez abierta con [Set], permanece abierta y deja pasar a todos los hilos hasta que se cierra explícitamente con [Reset]. Es la "señal de partida" de una carrera. El sufijo [Slim] designa las versiones ligeras de las herramientas de sincronización, introducidas con .NET 4: solo recurren al sistema operativo si la espera se prolonga y funcionan únicamente dentro de un proceso. El programa [threads-12.cs] es el siguiente:

// ManualResetEventSlim: una barrera que deja pasar a todos los hilos en espera

// la barrera, creada cerrada
using var start = new ManualResetEventSlim(false);

// creación e inicio de 4 hilos
var threads = new Thread[4];
for (int i = 0; i < threads.Length; i++)
{
    threads[i] = new Thread(() =>
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: runner {name} waits for the start signal");
        // espera de la apertura de la barrera
        start.Wait();
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: runner {name} has started");
    })
    { Name = i.ToString() };
    threads[i].Start();
}

// el hilo principal espera 1 s y luego da la señal de partida
Thread.Sleep(1000);
Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: start signal");
// la barrera se abre y permanece abierta: todos los hilos pasan
start.Set();
// espera del fin de los hilos
foreach (Thread thread in threads)
{
    thread.Join();
}
Console.WriteLine($"Is the barrier open? {start.IsSet}");

Comentarios:

  • línea 4: la barrera se crea en estado cerrado;
  • línea 15: cada hilo espera a que la barrera se abra;
  • línea 26: el hilo principal abre la barrera después de un segundo;
  • línea 32: la propiedad [IsSet] indica si la barrera está abierta.

Resultados:

> dotnet run threads-12.cs
11:36:48.866: runner 3 waits for the start signal
11:36:48.865: runner 0 waits for the start signal
11:36:48.866: runner 2 waits for the start signal
11:36:48.865: runner 1 waits for the start signal
11:36:49.865: start signal
11:36:49.865: runner 0 has started
11:36:49.865: runner 1 has started
11:36:49.865: runner 2 has started
11:36:49.865: runner 3 has started
Is the barrier open? True

Los cuatro corredores partieron juntos, al milisegundo, tras la señal de partida. Con un [AutoResetEvent], solo habría partido uno.

Un semáforo es una barrera provista de un contador: permite que como máximo N hilos entren a la vez en una sección de código. Es útil para limitar el uso de un recurso disponible en cantidades limitadas (conexiones a bases de datos, solicitudes simultáneas a un servidor, etc.). El programa [threads-13.cs] es el siguiente:

// SemaphoreSlim: como máximo N hilos a la vez en una sección de código

// un semáforo con 2 plazas
using var semaphore = new SemaphoreSlim(2);

// creación e inicio de 5 hilos
var threads = new Thread[5];
for (int i = 0; i < threads.Length; i++)
{
    threads[i] = new Thread(() =>
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: thread {name} waits for a slot");
        // solicitamos una plaza: bloqueante si no quedan
        semaphore.Wait();
        try
        {
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: thread {name} obtained a slot (free slots: {semaphore.CurrentCount})");
            // trabajo
            Thread.Sleep(1000);
        }
        finally
        {
            // devolvemos la plaza
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: thread {name} releases its slot");
            semaphore.Release();
        }
    })
    { Name = i.ToString() };
    threads[i].Start();
}
// espera del fin de los hilos
foreach (Thread thread in threads)
{
    thread.Join();
}

Comentarios:

  • línea 4: el semáforo tiene 2 espacios;
  • línea 15: un hilo solicita un espacio. Si hay uno disponible, lo toma y continúa; de lo contrario, se bloquea hasta que haya un espacio disponible;
  • línea 18: el número de espacios aún disponibles;
  • línea 26: el hilo devuelve su espacio, en una cláusula [finally].

Resultados:

> dotnet run threads-13.cs
11:36:51.985: thread 3 waits for a slot
11:36:51.985: thread 1 waits for a slot
11:36:51.985: thread 0 waits for a slot
11:36:51.985: thread 4 waits for a slot
11:36:51.985: thread 2 waits for a slot
11:36:52.035: thread 3 obtained a slot (free slots: 0)
11:36:52.035: thread 2 obtained a slot (free slots: 0)
11:36:53.035: thread 2 releases its slot
11:36:53.037: thread 3 releases its slot
11:36:53.037: thread 1 obtained a slot (free slots: 0)
11:36:53.037: thread 4 obtained a slot (free slots: 0)
11:36:54.037: thread 1 releases its slot
11:36:54.037: thread 4 releases its slot
11:36:54.037: thread 0 obtained a slot (free slots: 1)
11:36:55.037: thread 0 releases its slot

Los cinco hilos solicitan un espacio; dos lo obtienen de inmediato, mientras que los otros tres esperan. Cada vez que un hilo libera su espacio, un hilo en espera lo obtiene. Nunca hay más de dos hilos en la sección de código. Un semáforo de un solo espacio actúa como un cerrojo. La clase [SemaphoreSlim] también tiene un método [WaitAsync] que puede utilizarse con [await], que veremos en el próximo capítulo; la clase [Semaphore] (sin [Slim]), que consume más recursos, puede, al igual que [Mutex], tener nombre y compartirse entre procesos, pero solo en Windows.

8.5.6. La clase Interlocked

La clase [Interlocked] hace que operaciones simples sobre una variable sean atómicas: la operación la ejecuta el hilo por completo, sin que ningún otro hilo pueda observar o modificar la variable a mitad de la operación. Las herramientas anteriores ([lock], [Mutex], [AutoResetEvent]) están todas diseñadas para hacer atómico un grupo de operaciones, al costo de bloquear a otros hilos. Para operaciones simples pero frecuentes, la clase [Interlocked] evita este bloqueo mediante instrucciones especiales del procesador. Sus principales métodos estáticos son los siguientes:

Método
Función
[int Increment(ref int x)]
incrementa [x] en 1 y devuelve el nuevo valor
[int Decrement(ref int x)]
decrementa [x] en 1 y devuelve el nuevo valor
[int Add(ref int x, int value)]
suma [value] a [x] y devuelve el nuevo valor
[int Exchange(ref int x, int value)]
asigna [value] a [x] y devuelve el valor anterior
[int CompareExchange(ref int x, int value, int comparand)]
asigna [value] a [x] solo si [x] es igual a [comparand]; devuelve el valor anterior de [x]
[long Read(ref long x)]
lee atómicamente un valor de 64 bits (útil en un procesador de 32 bits)

Estos métodos están disponibles para los tipos [int], [long], [uint], [ulong]y, en el caso de [Exchange] y [CompareExchange], para otros tipos. Los métodos [And] y [Or] (.NET 5) realizan atómicamente una operación "y" u "o" bit a bit. El parámetro se pasa por referencia ([ref]): [Interlocked] debe operar sobre la variable misma, no sobre una copia. Por esta razón, la variable debe ser un campo o una variable local; una propiedad no puede pasarse por referencia.

El programa [threads-14.cs] retoma el experimento del programa [threads-07.cs] y compara tres formas de incrementar el contador compartido:

// la clase Interlocked: operaciones atómicas sin lock

using System.Diagnostics;

// parámetros: número de hilos, número de incrementos por hilo
int nbThreads = args.Length > 0 && int.TryParse(args[0], out int n) ? n : 4;
int nbIncrements = args.Length > 1 && int.TryParse(args[1], out int m) ? m : 10_000_000;
Console.WriteLine($"{nbThreads} threads, {nbIncrements:N0} increments per thread, expected value {nbThreads * nbIncrements:N0}");

// tres maneras de incrementar el contador compartido
Measure("without synchronization", Counter.WithoutSynchronization);
Measure("with lock", Counter.WithLock);
Measure("with Interlocked", Counter.WithInterlocked);

// inicia los hilos que ejecutan todos [increment] nbIncrements veces
void Measure(string method, Action increment)
{
    Counter.Value = 0;
    // una barrera para que todos los hilos arranquen al mismo tiempo
    using var start = new ManualResetEventSlim(false);
    var threads = new Thread[nbThreads];
    for (int i = 0; i < nbThreads; i++)
    {
        threads[i] = new Thread(() =>
        {
            start.Wait();
            for (int j = 0; j < nbIncrements; j++)
            {
                increment();
            }
        });
        threads[i].Start();
    }
    // ¡ya!
    var stopwatch = Stopwatch.StartNew();
    start.Set();
    foreach (Thread thread in threads)
    {
        thread.Join();
    }
    stopwatch.Stop();
    Console.WriteLine($"{method,-23}: obtained value {Counter.Value,12:N0} in {stopwatch.ElapsedMilliseconds,5} ms");
}

// el recurso compartido
static class Counter
{
    // un campo (y no una propiedad) para poder pasarlo por referencia
    public static int Value;
    private static readonly Lock padlock = new();

    // leer, incrementar, escribir: no atómico
    public static void WithoutSynchronization() => Value++;

    // sección crítica protegida por un lock
    public static void WithLock()
    {
        lock (padlock)
        {
            Value++;
        }
    }

    // incremento atómico, sin lock
    public static void WithInterlocked() => Interlocked.Increment(ref Value);
}

Comentarios:

  • línea 3: la clase [Stopwatch], que mide duraciones, se encuentra en el espacio de nombres [System.Diagnostics];
  • líneas 11–13: la función local [Measure] se llama con tres métodos de incremento distintos, pasados como un delegado [Action];
  • líneas 16–42: la función [Measure] lanza [nbThreads] hilos, cada uno de los cuales llama [nbIncrements] veces al método recibido, y mide el tiempo total con un [Stopwatch]. El formato [{Counter.Value,12:N0}] alinea el valor a la derecha en 12 caracteres;
  • líneas 20–26 y 36: los hilos esperan todos detrás de una barrera [ManualResetEventSlim], que se abre una vez que todos han sido lanzados. Esto les permite comenzar su trabajo simultáneamente, lo que hace el acceso concurrente mucho más probable que con hilos lanzados uno tras otro;
  • línea 49: el contador es un campo, no una propiedad, para poder pasarlo por referencia a [Interlocked.Increment];
  • línea 53: el incremento sin sincronización;
  • líneas 56–60: incremento dentro de una sección crítica protegida por un [Lock];
  • línea 65: incremento atómico.

Resultados:

1
2
3
4
5
> dotnet run threads-14.cs
4 threads, 10,000,000 increments per thread, expected value 40,000,000
without synchronization: obtained value   26,108,241 in   289 ms
with lock              : obtained value   40,000,000 in  2484 ms
with Interlocked       : obtained value   40,000,000 in   754 ms
  • Sin sincronización, el resultado es incorrecto, una vez más;
  • los otros dos métodos producen el resultado correcto;
  • [Interlocked] es notablemente más rápido que [lock] en esta ejecución. El cerrojo resulta costoso aquí porque cuatro hilos compiten constantemente por el mismo cerrojo para una operación minúscula. Los tiempos medidos dependen en gran medida de la máquina y de su carga: solo su orden de magnitud es significativo.

El método [CompareExchange] es el componente básico de los algoritmos "sin bloqueo" (lock-free): se lee el valor, se calcula el nuevo y se escribe solo si la variable no ha cambiado mientras tanto; de lo contrario, se vuelve a empezar. Las colecciones concurrentes que se presentan más adelante lo utilizan ampliamente.

8.6. Acceso concurrente a varios recursos compartidos

8.6.1. Interbloqueo (deadlock)

En nuestros ejemplos anteriores, se compartía un único recurso entre los distintos hilos. La situación se complica si hay varios recursos y dependen unos de otros. En particular, puede producirse un interbloqueo (deadlock): dos hilos se esperan mutuamente. Consideremos las siguientes acciones, que ocurren secuencialmente:

  • un hilo T1 adquiere el cerrojo V1 para acceder a un recurso compartido R1;
  • un hilo T2 adquiere el cerrojo V2 para acceder a un recurso compartido R2;
  • el hilo T1 solicita el cerrojo V2. Se bloquea;
  • el hilo T2 solicita el cerrojo V1. Se bloquea.

Los hilos T1 y T2 se esperan mutuamente de manera indefinida. Son posibles varias soluciones:

  • solicitar ambos recursos al mismo tiempo mediante un único cerrojo. Esto no siempre es posible si implica un bloqueo prolongado de un recurso costoso;
  • adquirir siempre los cerrojos en el mismo orden: si todos los hilos adquieren V1 antes que V2, el interbloqueo es imposible. Esta es la regla más utilizada;
  • un hilo que tiene V1 y no puede adquirir V2 libera V1 para evitar el interbloqueo.

El programa [threads-15.cs] provoca un interbloqueo e implementa la última solución:

// interbloqueo (deadlock): dos hilos toman dos locks en orden distinto

// los dos recursos compartidos y sus locks
Lock lockR1 = new();
Lock lockR2 = new();

// T1 toma R1 y luego solicita R2; se rinde después de 2 s
var t1 = new Thread(() => Work(lockR1, "R1", lockR2, "R2", TimeSpan.FromSeconds(2))) { Name = "T1" };
// T2 toma R2 y luego solicita R1; espera hasta 5 s
var t2 = new Thread(() => Work(lockR2, "R2", lockR1, "R1", TimeSpan.FromSeconds(5))) { Name = "T2" };
t1.Start();
t2.Start();
t1.Join();
t2.Join();
Console.WriteLine("End of Main");

// toma el 1.er recurso y luego intenta tomar el 2.º durante [timeout]
static void Work(Lock first, string firstName, Lock second, string secondName, TimeSpan timeout)
{
    string name = Thread.CurrentThread.Name ?? "?";
    lock (first)
    {
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} obtained {firstName}");
        // damos tiempo al otro hilo para que tome su primer recurso
        Thread.Sleep(500);
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} requests {secondName}");
        // solicitud con un tiempo máximo de espera, en lugar de un lock que esperaría indefinidamente
        if (second.TryEnter(timeout))
        {
            try
            {
                Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} obtained {secondName} and works with {firstName} and {secondName}");
            }
            finally
            {
                second.Exit();
            }
        }
        else
        {
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} did not obtain {secondName} within {timeout.TotalSeconds} s: it releases {firstName} and gives up");
        }
    }
}

Comentarios:

  • líneas 4–5: los cerrojos de los dos recursos. Aquí son variables locales, capturadas por las lambdas de las líneas 8–10;
  • línea 8: el hilo T1 adquiere R1 y luego solicita R2; espera como máximo 2 segundos;
  • Línea 10: el hilo T2 toma R2 y luego solicita R1, es decir, en orden inverso; espera como máximo 5 segundos;
  • Línea 21: el hilo adquiere su primer recurso;
  • línea 25: espera medio segundo, lo que da tiempo al otro hilo de adquirir su propio primer recurso: el interbloqueo es entonces seguro;
  • línea 28: en lugar de un [lock] que esperaría indefinidamente, el hilo solicita el segundo cerrojo con un tiempo de espera máximo. [TryEnter] devuelve [true] si se adquirió el cerrojo, o [false] si el tiempo de espera expiró;
  • línea 36: un cerrojo adquirido mediante [TryEnter] debe liberarse mediante [Exit], dentro de una cláusula [finally];
  • Líneas 39–41: si no se pudo adquirir el segundo cerrojo, el hilo se aborta. Al salir del bloque [lock], libera su primer recurso.

Resultados:

1
2
3
4
5
6
7
8
> dotnet run threads-15.cs
11:37:01.001: T1 obtained R1
11:37:01.001: T2 obtained R2
11:37:01.549: T1 requests R2
11:37:01.549: T2 requests R1
11:37:03.550: T1 did not obtain R2 within 2 s: it releases R1 and gives up
11:37:03.550: T2 obtained R1 and works with R2 and R1
End of Main

Cada uno de los dos hilos adquirió su primer recurso y luego solicitó el segundo: están en un interbloqueo. Después de 2 segundos, T1 se rinde y libera R1; T2, que seguía esperando, obtiene de inmediato R1 y puede hacer su trabajo. Sin un tiempo de espera, el programa nunca habría terminado.

8.6.2. Un ejemplo: lectores y escritores

Consideremos el siguiente ejemplo:

  • tenemos un arreglo en el que algunos hilos escriben datos (los escritores) y otros los leen (los lectores);
  • los escritores son iguales entre sí pero exclusivos: solo un escritor a la vez puede depositar datos en el arreglo;
  • los lectores son iguales entre sí pero exclusivos: solo un lector a la vez puede leer los datos almacenados en el arreglo;
  • un lector solo puede leer datos del arreglo cuando un escritor ha colocado algunos allí, y un escritor solo puede colocar nuevos datos en el arreglo cuando los datos que ya están allí han sido leídos por un lector.

Hay dos tipos de recursos compartidos:

  • el arreglo en el que se escribe: solo un escritor a la vez puede acceder a él;
  • el arreglo que se lee: solo un lector a la vez puede acceder a él.

y un orden de utilización de estos recursos:

  • un lector debe siempre seguir a un escritor;
  • un escritor debe siempre seguir a un lector, excepto la primera vez.

El acceso a estos dos recursos puede controlarse mediante dos barreras de tipo [AutoResetEvent]:

  • la barrera [canWrite] controla el acceso de los escritores al arreglo;
  • la barrera [canRead] controla el acceso de los lectores al arreglo;
  • la barrera [canWrite] se crea abierta, lo que permite pasar al primer escritor y bloquea a todos los demás;
  • La barrera [canRead] se crea en estado cerrado, bloqueando a todos los lectores;
  • cuando un escritor termina su trabajo, abre la barrera [canRead] para dejar pasar a un lector;
  • cuando un lector termina su trabajo, abre la barrera [canWrite] para dejar pasar a un escritor.

El programa [threads-16.cs] que ilustra esta sincronización es el siguiente:

// lectores y escritores sincronizados mediante dos barreras AutoResetEvent

// el número de hilos de cada tipo
const int nbThreads = 2;

// creación e inicio de los hilos lectores
for (int i = 0; i < nbThreads; i++)
{
    new Thread(Board.Read) { Name = $"R{i}" }.Start();
}
// creación e inicio de los hilos escritores
for (int i = 0; i < nbThreads; i++)
{
    new Thread(Board.Write) { Name = $"W{i}" }.Start();
}
// fin de Main: los demás hilos continúan su trabajo
Console.WriteLine("End of Main...");

// el recurso compartido y su sincronización
static class Board
{
    // el arreglo compartido entre lectores y escritores
    private static readonly int[] data = new int[3];
    // señala que el contenido de data puede leerse: cerrada al inicio
    private static readonly AutoResetEvent canRead = new(false);
    // señala que se puede escribir en data: abierta al inicio
    private static readonly AutoResetEvent canWrite = new(true);

    // lectura del contenido del arreglo
    public static void Read()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"Method [Read] started by thread {name}");
        // esperamos el permiso de lectura
        canRead.WaitOne();
        // lectura del arreglo
        for (int i = 0; i < data.Length; i++)
        {
            // espera de 0.5 s: el hilo pierde el procesador
            Thread.Sleep(500);
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: reader {name} read the number {data[i]}");
        }
        // permitimos a un escritor
        canWrite.Set();
        Console.WriteLine($"Method [Read] finished by thread {name}");
    }

    // escritura en el arreglo
    public static void Write()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"Method [Write] started by thread {name}");
        // esperamos el permiso de escritura
        canWrite.WaitOne();
        // escritura del arreglo
        for (int i = 0; i < data.Length; i++)
        {
            // espera de 0.5 s
            Thread.Sleep(500);
            // Random.Shared puede ser usado por varios hilos
            data[i] = Random.Shared.Next(0, 1000);
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: writer {name} wrote the number {data[i]}");
        }
        // permitimos a un lector
        canRead.Set();
        Console.WriteLine($"Method [Write] finished by thread {name}");
    }
}

Comentarios:

  • líneas 7–14: creación e inicio de dos hilos lectores, seguidos de dos hilos escritores. No se conserva ninguna referencia a los hilos: el hilo principal no los espera;
  • línea 17: el hilo principal termina de inmediato. El proceso continúa hasta que los cuatro hilos —que son hilos de primer plano— hayan terminado;
  • línea 23: el arreglo [data] es el recurso compartido entre los hilos lectores y escritores;
  • línea 25: la barrera [canRead] indica a los lectores que pueden leer el arreglo. La abre el escritor que ha llenado el arreglo. Se crea en estado cerrado: primero un escritor debe llenar el arreglo;
  • línea 27: la barrera [canWrite] notifica a los escritores que pueden escribir en el arreglo. La abre el lector que ha leído todo el arreglo. Se crea abierta: el arreglo es escribible desde el inicio;
  • línea 35: un lector espera a que un escritor señale que el arreglo ha sido llenado. Cuando llega esta señal, solo uno de los lectores en espera continúa;
  • líneas 37–41: se lee el arreglo, con una pausa de medio segundo en cada elemento para forzar al hilo a ceder la CPU;
  • línea 44: el lector notifica a los escritores que el arreglo ha sido leído y que puede llenarse de nuevo;
  • el método [Write] es simétrico al método [Read];
  • línea 61: los números escritos se generan de forma aleatoria. La propiedad [Random.Shared] (.NET 6) proporciona un generador compartido que puede usarse de forma segura desde varios hilos. El curso de 2008 compartía un objeto [Random] ordinario entre los hilos, cuyos métodos no están diseñados para ser llamados simultáneamente por varios hilos.

Resultados:

> dotnet run threads-16.cs
Method [Read] started by thread R1
Method [Read] started by thread R0
Method [Write] started by thread W0
Method [Write] started by thread W1
End of Main...
11:37:06.185: writer W0 wrote the number 359
11:37:06.719: writer W0 wrote the number 226
11:37:07.219: writer W0 wrote the number 693
Method [Write] finished by thread W0
11:37:07.719: reader R0 read the number 359
11:37:08.220: reader R0 read the number 226
11:37:08.720: reader R0 read the number 693
Method [Read] finished by thread R0
11:37:09.220: writer W1 wrote the number 325
11:37:09.720: writer W1 wrote the number 935
11:37:10.221: writer W1 wrote the number 96
Method [Write] finished by thread W1
11:37:10.721: reader R1 read the number 325
11:37:11.221: reader R1 read the number 935
11:37:11.722: reader R1 read the number 96
Method [Read] finished by thread R1

Vale la pena destacar los siguientes puntos:

  • Solo hay un lector a la vez, aunque ese lector pierde el procesador en la sección crítica [Read];
  • solo hay un escritor a la vez, aunque pierde el procesador en la sección crítica [Write];
  • un lector solo lee cuando hay algo que leer en el arreglo;
  • un escritor solo escribe cuando el arreglo ha sido leído por completo;
  • sin embargo, el orden de ejecución no puede controlarse: no había ninguna razón para que el escritor W0 fuera antes que el escritor W1, ni para que el lector R0 fuera antes que el lector R1. Otra ejecución puede dar un orden distinto.

8.6.3. La clase Monitor

En el ejemplo anterior, cuando los escritores están bloqueados en la instrucción [canWrite.WaitOne()], uno de ellos —cualquiera— se desbloquea mediante la operación [canWrite.Set()]. Si se desea abrir la barrera para un escritor específico, las cosas se complican.

Consideremos la analogía de una oficina de atención al público con ventanillas. Cuando llega un cliente, toma un número del dispensador y luego va a sentarse. Los clientes son llamados por su número mediante un altavoz. Mientras espera, el cliente puede hacer lo que quiera: leer o dormitar. Se despierta cada vez que el altavoz anuncia un número. Si es su número, el cliente se levanta y va a la ventanilla; de lo contrario, vuelve a lo que estaba haciendo. Podemos operar de manera similar con los hilos. Tomemos el ejemplo de los escritores:

En la ventanilla
Con hilos
varios escritores esperan la misma ventanilla
sus hilos están bloqueados
la ventanilla queda disponible y se llama el número del siguiente escritor
el hilo que leía el arreglo notifica a los escritores que el arreglo está disponible. Ese hilo u otro ha determinado qué escritor debe continuar
Cada escritor verifica su número; solo el que tiene el número llamado pasa a la ventanilla; los demás vuelven a la cola de espera
Cada hilo verifica si es el seleccionado. Si lo es, atraviesa la barrera; de lo contrario, vuelve a la cola de espera

La clase [Monitor] implementa este escenario. Sus métodos estáticos son los siguientes:

Método
Función
[Enter(object token)]
Solicita el token: el hilo lo obtiene si está libre; de lo contrario, se bloquea hasta que quede libre
[bool TryEnter(object token, TimeSpan timeout)]
Igual que el anterior, con un tiempo de espera máximo
[Exit(object token)]
devuelve el token
[bool Wait(object token)]
devuelve el token y bloquea el hilo hasta que otro hilo señale un cambio mediante [Pulse] o [PulseAll]; el hilo debe entonces recuperar el token antes de continuar
[Pulse(object token)]
despierta a uno de los hilos bloqueados por [Wait] en este token
[PulseAll(object token)]
despierta a todos los hilos bloqueados por [Wait] en este token

A continuación describiremos un patrón estándar, propuesto en el capítulo «Threading» del libro de J. y B. Albahari, [C# in a Nutshell], capaz de resolver problemas de barreras con una condición de entrada.

Los hilos que comparten un recurso (la ventanilla) acceden a él mediante un objeto que llamaremos token. Para atravesar la barrera que conduce a la ventanilla se necesita tener el token, y solo hay uno. Por lo tanto, los hilos deben pasarse el token entre sí:

object token = new();

Para ir a la ventanilla, un hilo solicita primero el token mediante [Monitor.Enter(token)], o más simplemente con una cláusula [lock]. Si obtiene el token, verifica que cumple la condición para ir a la ventanilla:

1
2
3
4
5
6
7
8
9
lock (token)
{
    while (!iAmTheOneExpected)
    {
        Monitor.Wait(token);
    }
    // pasando por el contador
    ...
}

Si el hilo no es el esperado en la ventanilla, cede su turno devolviendo el token mediante [Monitor.Wait(token)] y entra en un estado bloqueado. Será despertado cuando otro hilo señale un cambio en la condición de acceso; entonces recuperará el token y verificará de nuevo la condición. Por eso la verificación es un bucle ([while]) y no un simple [if]. La operación [Monitor.Wait(token)] solo puede ser realizada por un hilo que posea el token; de lo contrario, se lanza una excepción [SynchronizationLockException]. En este escenario, el token solo se libera una vez completada la operación.

El hilo que modifica la condición de acceso a la ventanilla también debe poseer el token y notificar a los hilos en espera:

1
2
3
4
5
6
7
lock (token)
{
    // modificar la condición de acceso al contador
    ...
    // despertar a los hilos que esperan el token
    Monitor.PulseAll(token);
}

Despertar a los hilos significa que los hilos en espera pasan a ser candidatos al token; no lo reciben de inmediato. El token solo queda disponible al final del bloque [lock]. Todos los hilos despertados recibirán entonces el token por turnos, en un orden indeterminado, lo que les da la oportunidad de verificar de nuevo la condición de acceso. El primero que cumpla la condición conserva el token y pasa a la ventanilla.

Una nota importante: los métodos [Wait], [Pulse] y [PulseAll] de [Monitor] se aplican a un objeto bloqueado mediante [lock (obj)] o [Monitor.Enter(obj)]. No funcionan con el tipo [Lock] de .NET 9, que no tiene equivalente. Por lo tanto, los tokens de este apartado son objetos de tipo [object].

Con esta información, podemos reescribir la aplicación de lectores/escritores especificando el orden en que los lectores y escritores acceden a sus respectivas ventanillas [threads-17.cs]:

// lectores y escritores que pasan por el contador en un orden impuesto: Monitor.Wait / Monitor.PulseAll

// el número de hilos de cada tipo
const int nbThreads = 3;

// el orden de los lectores: el inverso al orden de creación
Board.ReadOrder = [.. Enumerable.Range(0, nbThreads).Select(i => $"R{nbThreads - 1 - i}")];
// el orden de los escritores: el orden de creación
Board.WriteOrder = [.. Enumerable.Range(0, nbThreads).Select(i => $"W{i}")];
for (int i = 0; i < nbThreads; i++)
{
    Console.WriteLine($"Reader {Board.ReadOrder[i]} is in position {i}, writer {Board.WriteOrder[i]} is in position {i}");
}

// creación e inicio de los hilos lectores y luego de los hilos escritores
for (int i = 0; i < nbThreads; i++)
{
    new Thread(Board.Read) { Name = $"R{i}" }.Start();
}
for (int i = 0; i < nbThreads; i++)
{
    new Thread(Board.Write) { Name = $"W{i}" }.Start();
}

// permiso de escritura
Board.AllowWriting();
// fin de Main
Console.WriteLine("End of Main...");

// el recurso compartido y su sincronización
static class Board
{
    // el arreglo compartido entre lectores y escritores
    private static readonly int[] data = new int[3];
    // los tokens de acceso de los contadores de lectura y de escritura
    private static readonly object canRead = new();
    private static readonly object canWrite = new();
    // las condiciones de acceso de los contadores
    private static bool readingAllowed = false;
    private static bool writingAllowed = false;
    private static int nextReader = 0;
    private static int nextWriter = 0;
    // el orden de los lectores y de los escritores
    public static string[] ReadOrder { get; set; } = [];
    public static string[] WriteOrder { get; set; } = [];

    // abre el contador de escritura
    public static void AllowWriting()
    {
        lock (canWrite)
        {
            writingAllowed = true;
            // despertamos a todos los escritores que esperan el token
            Monitor.PulseAll(canWrite);
        }
    }

    // lectura del contenido del arreglo
    public static void Read()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"Method [Read] started by thread {name}");
        // solicitamos el token del contador de lectura
        lock (canRead)
        {
            // mientras no sea nuestro turno, devolvemos el token y esperamos
            while (!readingAllowed || ReadOrder[nextReader] != name)
            {
                Monitor.Wait(canRead);
            }
            // en el contador: lectura del arreglo
            for (int i = 0; i < data.Length; i++)
            {
                Thread.Sleep(500);
                Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: reader {name} read the number {data[i]}");
            }
            // siguiente lector
            readingAllowed = false;
            nextReader++;
            // notificamos a los escritores que pueden escribir
            lock (canWrite)
            {
                writingAllowed = true;
                Monitor.PulseAll(canWrite);
            }
            Console.WriteLine($"Method [Read] finished by thread {name}");
        }
    }

    // escritura en el arreglo
    public static void Write()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"Method [Write] started by thread {name}");
        // solicitamos el token del contador de escritura
        lock (canWrite)
        {
            // mientras no sea nuestro turno, devolvemos el token y esperamos
            while (!writingAllowed || WriteOrder[nextWriter] != name)
            {
                Monitor.Wait(canWrite);
            }
            // en el contador: escritura del arreglo
            for (int i = 0; i < data.Length; i++)
            {
                Thread.Sleep(500);
                data[i] = Random.Shared.Next(0, 1000);
                Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: writer {name} wrote the number {data[i]}");
            }
            // siguiente escritor
            writingAllowed = false;
            nextWriter++;
            // notificamos a los lectores que pueden leer
            lock (canRead)
            {
                readingAllowed = true;
                Monitor.PulseAll(canRead);
            }
            Console.WriteLine($"Method [Write] finished by thread {name}");
        }
    }
}

El acceso a la ventanilla de lectura está condicionado por los siguientes elementos:

  • línea 36: el token [canRead];
  • línea 39: el booleano [readingAllowed];
  • línea 44: el arreglo ordenado de nombres de lectores. Los lectores pasan a la ventanilla de lectura en el orden especificado por este arreglo;
  • línea 41: [nextReader] es el índice en este arreglo del siguiente lector autorizado a pasar a la ventanilla.

El acceso a la ventanilla de escritura se controla de manera similar mediante el token [canWrite], el booleano [writingAllowed], el arreglo [WriteOrder] y el índice [nextWriter].

El programa principal:

  • líneas 7–9: los lectores pasarán a la ventanilla en orden inverso al de su creación (R2, R1, R0), y los escritores en el orden en que fueron creados (W0, W1, W2). Los arreglos se construyen mediante una expresión de colección [.. sequence], que crea un arreglo a partir de una consulta LINQ;
  • líneas 18–22: creación e inicialización de los lectores, seguidos de los escritores. Todos quedarán bloqueados, ya que no se permite ni leer ni escribir;
  • línea 26: se habilita la escritura y se notifica a los escritores que algo ha cambiado (método [AllowWriting], líneas 48–54).

El método [Read]:

  • líneas 64–86: todo el proceso en la ventanilla de lectura está controlado por [lock] sobre el token [canRead]. El lector que lo obtiene lo conserva durante todo su paso por la ventanilla;
  • líneas 67–69: un lector que ha adquirido el token lo devuelve si la lectura no está autorizada o si no es su turno;
  • líneas 72–75: paso por la ventanilla (lectura de la tabla);
  • líneas 78–79: el lector cambia las condiciones de acceso a la ventanilla de lectura. Todavía posee el token de lectura, y estos cambios impiden que cualquier otro lector acceda a la ventanilla;
  • líneas 81–84: el lector cambia las condiciones de acceso a la ventanilla de escritura y notifica a todos los escritores en espera que algo ha cambiado. Para ello, toma el token [canWrite]: aquí vemos que el hilo posee dos tokens al mismo tiempo. Los escritores hacen lo mismo en orden inverso (poseen [canWrite] y solicitan [canRead]), que es la situación de interbloqueo descrita anteriormente. Sin embargo, aquí no hay riesgo: un hilo solicita el segundo token solo al final de su paso por la ventanilla; las dos ventanillas nunca están ocupadas al mismo tiempo; y los demás hilos poseen un token solo el tiempo necesario para verificar la condición de acceso, sin solicitar el otro token.

El método [Write] es simétrico al método [Read]. El curso de 2008 utilizaba, en el programa principal, [Monitor.Pulse], que despierta solo a un hilo: si ese hilo no era el escritor esperado, volvía a dormirse, y el escritor esperado podía no despertarse nunca. Cuando se utiliza una condición de acceso que especifica un hilo en particular, se debe usar [PulseAll].

Este es un ejemplo de ejecución:

> dotnet run threads-17.cs
Reader R2 is in position 0, writer W0 is in position 0
Reader R1 is in position 1, writer W1 is in position 1
Reader R0 is in position 2, writer W2 is in position 2
Method [Read] started by thread R0
Method [Read] started by thread R1
Method [Read] started by thread R2
End of Main...
Method [Write] started by thread W0
Method [Write] started by thread W2
Method [Write] started by thread W1
11:37:14.240: writer W0 wrote the number 550
11:37:14.789: writer W0 wrote the number 13
11:37:15.290: writer W0 wrote the number 5
Method [Write] finished by thread W0
11:37:15.790: reader R2 read the number 550
11:37:16.290: reader R2 read the number 13
11:37:16.791: reader R2 read the number 5
Method [Read] finished by thread R2
11:37:17.291: writer W1 wrote the number 962
11:37:17.791: writer W1 wrote the number 475
11:37:18.292: writer W1 wrote the number 167
Method [Write] finished by thread W1
11:37:18.792: reader R1 read the number 962
11:37:19.292: reader R1 read the number 475
11:37:19.793: reader R1 read the number 167
Method [Read] finished by thread R1
11:37:20.293: writer W2 wrote the number 849
11:37:20.793: writer W2 wrote the number 31
11:37:21.294: writer W2 wrote the number 817
Method [Write] finished by thread W2
11:37:21.794: reader R0 read the number 849
11:37:22.295: reader R0 read the number 31
11:37:22.795: reader R0 read the number 817
Method [Read] finished by thread R0

Los escritores y lectores se turnan en sus respectivas ventanillas, cada uno en el orden especificado: W0, R2, W1, R1, W2, R0.

8.7. Colecciones concurrentes

Los ejemplos anteriores protegían datos compartidos muy simples (un contador, un arreglo). Cuando los hilos comparten una colección (lista, diccionario, cola), se podría proteger cada acceso con un [lock]. Pero las colecciones ordinarias ([List<T>], [Dictionary<TKey,TValue>], [Queue<T>]) no están diseñadas para ser modificadas por varios hilos simultáneamente: su uso sin protección puede provocar la pérdida de elementos, desencadenar excepciones inesperadas o incluso corromper la estructura interna de la colección. A partir de .NET 4, el espacio de nombres [System.Collections.Concurrent] ofrece colecciones diseñadas para compartirse entre hilos sin bloqueo explícito:

Colección
Función
[ConcurrentDictionary<TKey,TValue>]
un diccionario cuyas operaciones, incluidas las actualizaciones condicionales, son seguras
[ConcurrentQueue<T>]
una cola (primero en entrar, primero en salir)
[ConcurrentStack<T>]
una pila (último en entrar, primero en salir)
[ConcurrentBag<T>]
una bolsa: una colección sin orden
[BlockingCollection<T>]
un envoltorio de las colecciones anteriores que bloquea al consumidor cuando la colección está vacía y, opcionalmente, al productor cuando está llena

8.7.1. ConcurrentDictionary y ConcurrentQueue

En el programa [threads-18.cs], cuatro hilos generan números aleatorios y cuentan el número de veces que aparece cada número en un diccionario compartido:

// colecciones concurrentes: ConcurrentDictionary y ConcurrentQueue

using System.Collections.Concurrent;

// el diccionario compartido: dígito -> número de sorteos
var draws = new ConcurrentDictionary<int, int>();
// la cola compartida de los informes de los hilos
var reports = new ConcurrentQueue<string>();

// 4 hilos sortean cada uno 100,000 dígitos aleatorios
const int nbDraws = 100_000;
var threads = new Thread[4];
for (int i = 0; i < threads.Length; i++)
{
    threads[i] = new Thread(() =>
    {
        for (int j = 0; j < nbDraws; j++)
        {
            int digit = Random.Shared.Next(0, 10);
            // agregado de la clave con el valor 1 o actualización atómica del valor existente
            draws.AddOrUpdate(digit, 1, (key, oldValue) => oldValue + 1);
        }
        // informe puesto en la cola
        reports.Enqueue($"thread {Thread.CurrentThread.Name} has finished its {nbDraws:N0} draws");
    })
    { Name = $"T{i}" };
    threads[i].Start();
}
foreach (Thread thread in threads)
{
    thread.Join();
}

// los informes, en su orden de llegada
while (reports.TryDequeue(out string? report))
{
    Console.WriteLine(report);
}
// los resultados de los sorteos
foreach (var (digit, count) in draws.OrderBy(pair => pair.Key))
{
    Console.WriteLine($"digit {digit}: {count,6:N0} draws");
}
Console.WriteLine($"total: {draws.Values.Sum():N0} draws (expected: {threads.Length * nbDraws:N0})");
// GetOrAdd: devuelve el valor asociado a la clave, tras agregarlo si no existía
Console.WriteLine($"GetOrAdd(10, 0) = {draws.GetOrAdd(10, 0)}, number of keys: {draws.Count}");

Comentarios:

  • línea 3: el espacio de nombres de las colecciones concurrentes;
  • línea 6: el diccionario compartido asocia cada dígito con su número de ocurrencias;
  • línea 8: una cola en la que cada hilo deposita un informe al final de su trabajo;
  • línea 21: el método [AddOrUpdate] agrega la clave [digit] con el valor 1 si no existe, y en caso contrario reemplaza su valor por el calculado por la función [(key, oldValue) => oldValue + 1]. La operación es atómica. No podríamos escribir [draws[digit]++]: esta expresión lee el valor y luego escribe el nuevo, en dos operaciones, y dos hilos podrían perder una actualización como en el ejemplo [threads-07.cs];
  • línea 24: cada hilo coloca su informe en la cola;
  • líneas 35–37: el hilo principal vacía la cola. [TryDequeue] devuelve [false] cuando la cola está vacía. Las colecciones concurrentes solo ofrecen métodos «Try…» que combinan la verificación y la operación: una verificación de [Count > 0] seguida de una extracción no sería segura, ya que otro hilo podría vaciar la cola entre ambas;
  • línea 40: el diccionario se recorre en orden de claves; cada par clave/valor se descompone en dos variables;
  • línea 46: el método [GetOrAdd] devuelve el valor asociado con la clave, después de agregar la clave con el valor proporcionado si no existía.

Resultados:

> dotnet run threads-18.cs
thread T0 has finished its 100,000 draws
thread T2 has finished its 100,000 draws
thread T1 has finished its 100,000 draws
thread T3 has finished its 100,000 draws
digit 0: 40,168 draws
digit 1: 39,980 draws
digit 2: 39,982 draws
digit 3: 39,856 draws
digit 4: 40,170 draws
digit 5: 40,271 draws
digit 6: 40,081 draws
digit 7: 39,704 draws
digit 8: 39,722 draws
digit 9: 40,066 draws
total: 400,000 draws (expected: 400,000)
GetOrAdd(10, 0) = 0, number of keys: 11

El número total de sorteos es correcto: no se perdió ninguna actualización. Los informes aparecen en el orden en que los hilos terminaron su trabajo.

8.7.2. Productores y consumidores: BlockingCollection

El problema de lectores y escritores es una variante del problema clásico de productor-consumidor: unos hilos producen datos que otros hilos consumen. La clase [BlockingCollection<T>] lo resuelve sin ninguna herramienta de sincronización explícita:

  • [Add(element)] agrega un elemento. Si la colección tiene una capacidad limitada y está llena, el productor se bloquea hasta que quede un espacio disponible;
  • [CompleteAdding()] señala que no se agregarán más elementos;
  • [GetConsumingEnumerable()] devuelve una enumeración que extrae los elementos uno a uno. Si la colección está vacía, el consumidor se bloquea hasta que llegue un elemento; la enumeración termina cuando la colección está vacía y se ha llamado a [CompleteAdding] .

El programa [threads-19.cs] es el siguiente:

// productor / consumidores con BlockingCollection<T>

using System.Collections.Concurrent;

// una cola de como máximo 3 elementos
using var queue = new BlockingCollection<int>(boundedCapacity: 3);

// el productor pone 8 números y luego señala que terminó
var producer = new Thread(() =>
{
    for (int i = 1; i <= 8; i++)
    {
        // bloqueante si la cola está llena
        queue.Add(i);
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: P put {i} (waiting elements: {queue.Count})");
        Thread.Sleep(100);
    }
    // ya no se agregarán más elementos
    queue.CompleteAdding();
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: P has finished");
});

// dos consumidores toman los números mientras haya
var consumers = new Thread[2];
for (int i = 0; i < consumers.Length; i++)
{
    consumers[i] = new Thread(() =>
    {
        string name = Thread.CurrentThread.Name ?? "?";
        // la enumeración espera los elementos y se detiene cuando la cola está vacía y completada
        foreach (int number in queue.GetConsumingEnumerable())
        {
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} took {number}");
            // procesamiento del número
            Thread.Sleep(600);
        }
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} has finished");
    })
    { Name = $"C{i + 1}" };
}

// inicio y espera de todos los hilos
producer.Start();
foreach (Thread consumer in consumers)
{
    consumer.Start();
}
producer.Join();
foreach (Thread consumer in consumers)
{
    consumer.Join();
}

Comentarios:

  • línea 6: una cola (la colección subyacente predeterminada es una [ConcurrentQueue<int>]) que contiene como máximo 3 elementos. El parámetro se pasa por nombre, lo que hace la llamada más legible;
  • líneas 9–20: el productor deposita los números del 1 al 8, uno cada décima de segundo, y luego señala que ha terminado;
  • líneas 24–37: dos consumidores obtienen los números y dedican 0,6 segundos a procesar cada uno. Los consumen más lentamente de lo que el productor los genera;
  • línea 31: la enumeración bloqueante. Cada número es obtenido por uno solo de los dos consumidores.

Resultados:

> dotnet run threads-19.cs
11:37:27.216: C2 took 1
11:37:27.213: P put 1 (waiting elements: 0)
11:37:27.366: P put 2 (waiting elements: 1)
11:37:27.366: C1 took 2
11:37:27.466: P put 3 (waiting elements: 1)
11:37:27.566: P put 4 (waiting elements: 2)
11:37:27.666: P put 5 (waiting elements: 3)
11:37:27.866: C2 took 3
11:37:27.866: P put 6 (waiting elements: 3)
11:37:27.966: C1 took 4
11:37:27.966: P put 7 (waiting elements: 3)
11:37:28.466: C2 took 5
11:37:28.466: P put 8 (waiting elements: 3)
11:37:28.566: C1 took 6
11:37:28.567: P has finished
11:37:29.066: C2 took 7
11:37:29.167: C1 took 8
11:37:29.667: C2 has finished
11:37:29.767: C1 has finished

Vemos que el productor encola rápidamente los primeros números y luego —en cuanto la cola contiene 3 elementos— solo encola un número cuando un consumidor extrae uno: queda bloqueado en [Add] cuando la cola está llena. Los consumidores se reparten los números y se detienen cuando la cola está vacía y el proceso ha terminado. Observe que el consumidor C2 mostró la obtención del número 1 antes de que el productor mostrara su inserción: la inserción ocurrió efectivamente antes, pero el productor fue interrumpido entre [Add] y su visualización.

La clase [Channel<T>] del espacio de nombres [System.Threading.Channels] proporciona el mismo servicio para la programación asíncrona: un consumidor que espera un elemento no bloquea ningún hilo. Lo veremos en el próximo capítulo.

8.8. El grupo de hilos

Hasta ahora, para gestionar hilos, los hemos creado mediante [new Thread(...)] y luego los hemos ejecutado mediante [Start()]. Crear un hilo es una operación relativamente costosa: en particular, el sistema debe asignarle una pila, y cada hilo ocupa memoria mientras exista. Veremos en el capítulo sobre bases de datos que existen grupos de conexiones: las conexiones abiertas se mantienen en reserva y se prestan a los hilos que las solicitan, ya que abrir una conexión es costoso. Existe un sistema similar para los hilos: el grupo de hilos (ThreadPool) de .NET.

  • Mientras el número de hilos del grupo esté por debajo de un umbral mínimo, el grupo crea de inmediato un nuevo hilo para cada tarea que no encuentra un hilo libre. De forma predeterminada, este mínimo es el número de procesadores; puede leerse mediante [ThreadPool.GetMinThreads(out min1, out min2)] y modificarse mediante [ThreadPool.SetMinThreads(min1, min2)]. El grupo gestiona dos tipos de hilos: los hilos de trabajo (min1), que ejecutan los trabajos que se les asignan, y los hilos de E/S asíncrona (min2);
  • si este número es insuficiente, el grupo crea hilos adicionales de forma incremental, hasta un máximo que puede leerse mediante [ThreadPool.GetMaxThreads(out max1, out max2)] y modificarse mediante [ThreadPool.SetMaxThreads(max1, max2)]. Cuando se alcanza el máximo, los trabajos asignados al grupo se ponen en cola hasta que un hilo quede disponible;
  • Un hilo que ha completado una tarea no se destruye: se devuelve al grupo y se utiliza para la siguiente tarea.

El grupo de hilos ofrece dos ventajas: ahorra el tiempo dedicado a crear hilos (unos pocos hilos pueden atender cientos de solicitudes) y, al limitar el número de hilos, evita que la aplicación se vea desbordada por demasiadas solicitudes.

Para asignar una tarea al grupo, se utiliza el método [ThreadPool.QueueUserWorkItem(WaitCallback callback, object? state)], donde [WaitCallback] es un delegado de firma [void M(object? state)]. La tarea será ejecutada por un hilo del grupo, con el parámetro [state]. El programa [threads-20.cs] es el siguiente:

// el grupo de hilos (thread pool)

// el hilo principal
Thread.CurrentThread.Name = "Main";

// número mínimo de hilos en el grupo
ThreadPool.GetMinThreads(out int min1, out int min2);
Console.WriteLine($"Minimum number of worker threads in the pool: {min1}");
Console.WriteLine($"Minimum number of asynchronous I/O threads in the pool: {min2}");
ThreadPool.SetMinThreads(3, min2);
ThreadPool.GetMinThreads(out min1, out _);
Console.WriteLine($"Minimum number of worker threads after change: {min1}");
// número máximo de hilos en el grupo
ThreadPool.GetMaxThreads(out int max1, out int max2);
Console.WriteLine($"Maximum number of worker threads in the pool: {max1}");
Console.WriteLine($"Maximum number of asynchronous I/O threads in the pool: {max2}");
bool ok = ThreadPool.SetMaxThreads(5, max2);
ThreadPool.GetMaxThreads(out max1, out _);
Console.WriteLine($"Maximum number of worker threads after change: {max1} (SetMaxThreads returned {ok})");

// entregamos 7 trabajos al grupo; la cuenta regresiva nos permite esperar su fin
using var remainingJobs = new CountdownEvent(7);
for (int i = 0; i < 7; i++)
{
    var data = new Data { Number = i, Start = DateTime.Now, Duration = 3 };
    ThreadPool.QueueUserWorkItem(Sleep, data);
}
Console.WriteLine($"At {DateTime.Now:HH:mm:ss.ff}, the Main thread has handed the 7 jobs to the pool and waits for their end");
// espera del fin de los 7 trabajos
remainingJobs.Wait();
Console.WriteLine($"At {DateTime.Now:HH:mm:ss.ff}, end of the Main thread");

// el trabajo ejecutado por un hilo del grupo
void Sleep(object? state)
{
    if (state is not Data data)
    {
        return;
    }
    // estado del grupo
    ThreadPool.GetAvailableThreads(out int available, out _);
    Console.WriteLine($"At {DateTime.Now:HH:mm:ss.ff}, job no. {data.Number} starts in thread {Thread.CurrentThread.ManagedThreadId} for {data.Duration} s (available worker threads: {available})");
    // pausa de Duration segundos
    Thread.Sleep(data.Duration * 1000);
    DateTime end = DateTime.Now;
    Console.WriteLine($"At {end:HH:mm:ss.ff}, job no. {data.Number} ends: scheduled for {data.Duration} s, it lasted {(end - data.Start).TotalSeconds:F2} s since its request");
    // un trabajo menos
    remainingJobs.Signal();
}

// la información pasada a cada trabajo
class Data
{
    public int Number { get; init; }
    public DateTime Start { get; init; }
    public int Duration { get; init; }
}

Comentarios:

  • líneas 7–12: se lee y se muestra el número mínimo actual de ambos tipos de hilos del grupo, y luego se establece en 3 el número mínimo de hilos de trabajo. El parámetro [out _] es un «parámetro descartado»: no nos interesa el valor devuelto;
  • líneas 14–19: hacemos lo mismo para establecer en 5 el número máximo de hilos de trabajo. [SetMaxThreads] devuelve [false] si el valor solicitado es rechazado, por ejemplo, si es menor que el número de procesadores;
  • línea 22: un objeto [CountdownEvent] actúa como un temporizador de cuenta regresiva: cada llamada a su método [Signal] lo decrementa, y su método [Wait] bloquea el hilo que llama hasta que llega a 0. Aquí permite que el hilo principal espere a que terminen los 7 trabajos: no se puede llamar a [Join] sobre un hilo del grupo, ya que no es de su propiedad. El curso de 2008 pedía al usuario que presionara [Enter] una vez completados los trabajos;
  • líneas 23–26: asignamos al grupo 7 tareas, cada una de 3 segundos de duración, aunque el grupo nunca tendrá más de 5 hilos de trabajo. Cada tarea recibe un objeto [Data];
  • línea 30: el hilo principal espera a que terminen los 7 trabajos;
  • líneas 34–48: la tarea ejecutada por un hilo del grupo. Es una función local no estática porque utiliza la variable local [remainingJobs];
  • línea 41: el número de hilos de trabajo aún disponibles (el máximo menos el número de hilos ocupados);
  • línea 48: el contador se decrementa al final de cada trabajo.

Resultados:

> dotnet run threads-20.cs
Minimum number of worker threads in the pool: 2
Minimum number of asynchronous I/O threads in the pool: 1
Minimum number of worker threads after change: 3
Maximum number of worker threads in the pool: 32767
Maximum number of asynchronous I/O threads in the pool: 1000
Maximum number of worker threads after change: 5 (SetMaxThreads returned True)
At 11:37:31.85, the Main thread has handed the 7 jobs to the pool and waits for their end
At 11:37:31.85, job no. 1 starts in thread 6 for 3 s (available worker threads: 2)
At 11:37:31.85, job no. 0 starts in thread 4 for 3 s (available worker threads: 2)
At 11:37:31.85, job no. 2 starts in thread 7 for 3 s (available worker threads: 2)
At 11:37:32.85, job no. 3 starts in thread 8 for 3 s (available worker threads: 1)
At 11:37:33.85, job no. 4 starts in thread 9 for 3 s (available worker threads: 0)
At 11:37:34.85, job no. 0 ends: scheduled for 3 s, it lasted 3.04 s since its request
At 11:37:34.85, job no. 1 ends: scheduled for 3 s, it lasted 3.00 s since its request
At 11:37:34.85, job no. 2 ends: scheduled for 3 s, it lasted 3.00 s since its request
At 11:37:34.85, job no. 5 starts in thread 7 for 3 s (available worker threads: 0)
At 11:37:34.85, job no. 6 starts in thread 4 for 3 s (available worker threads: 0)
At 11:37:35.85, job no. 3 ends: scheduled for 3 s, it lasted 4.00 s since its request
At 11:37:36.85, job no. 4 ends: scheduled for 3 s, it lasted 5.00 s since its request
At 11:37:37.85, job no. 6 ends: scheduled for 3 s, it lasted 6.00 s since its request
At 11:37:37.85, job no. 5 ends: scheduled for 3 s, it lasted 6.00 s since its request
At 11:37:37.85, end of the Main thread
  • En esta máquina de doble procesador, el grupo tenía inicialmente un mínimo de 2 hilos de trabajo y un máximo de 32 767;
  • los trabajos 0, 1 y 2 comenzaron de inmediato: el grupo tiene un mínimo de 3 hilos;
  • los trabajos 3 y 4 comenzaron con retrasos de uno y dos segundos, respectivamente: ya no quedaban hilos libres y el grupo —una vez que supera su mínimo— crea nuevos hilos solo gradualmente mientras haya trabajos en espera. Entonces se alcanza el máximo de 5 hilos: no queda ningún hilo disponible;
  • Los trabajos 5 y 6 tuvieron que esperar a que un hilo quedara disponible tras terminar los trabajos 0, 1 y 2. Vemos que reutilizaron los hilos 7 y 4, que habían ejecutado los primeros trabajos;
  • En total, los trabajos 5 y 6 tardaron 6 segundos desde el momento en que se solicitaron: 3 segundos de espera y 3 segundos de ejecución.

Rara vez es necesario cambiar los límites del grupo: sus valores predeterminados son adecuados para la mayoría de las aplicaciones. De hecho, [QueueUserWorkItem] rara vez se usa directamente: trabajamos mediante tareas, que se describen a continuación.

8.9. Tareas y la biblioteca paralela

8.9.1. Task.Run

Desde .NET 4, la clase [System.Threading.Tasks.Task] representa un trabajo (una tarea) que se ejecuta de forma asíncrona. [Task.Run(action)] asigna un trabajo al grupo de hilos, igual que [QueueUserWorkItem], pero devuelve un objeto [Task] que permite hacer el seguimiento de ese trabajo: verificar si ha terminado, esperarlo, obtener su resultado o la excepción que lanzó. Una tarea que devuelve un resultado de tipo T es de tipo [Task<T>]. El programa [threads-21.cs] es el siguiente:

// Task.Run: entrega un trabajo al grupo de hilos y obtiene su resultado

Console.WriteLine($"Main thread: id {Thread.CurrentThread.ManagedThreadId}, pool thread: {Thread.CurrentThread.IsThreadPoolThread}");

// tres tareas que devuelven cada una un resultado de tipo int
var tasks = new Task<int>[3];
for (int i = 0; i < tasks.Length; i++)
{
    int number = i;
    tasks[i] = Task.Run(() =>
    {
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: task {number} runs in thread {Thread.CurrentThread.ManagedThreadId} (pool thread: {Thread.CurrentThread.IsThreadPoolThread})");
        // trabajo
        Thread.Sleep(500 * (number + 1));
        // el resultado de la tarea
        return number * 10;
    });
}
// espera del fin de las tres tareas (bloqueante)
Task.WaitAll(tasks);
// los resultados
for (int i = 0; i < tasks.Length; i++)
{
    Console.WriteLine($"task {i}: status {tasks[i].Status}, result {tasks[i].Result}");
}

// una tarea que lanza una excepción
Task failingTask = Task.Run(Fail);
try
{
    // la excepción de la tarea es relanzada por Wait, envuelta en una AggregateException
    failingTask.Wait();
}
catch (AggregateException e)
{
    Console.WriteLine($"{e.GetType().Name} containing {e.InnerException?.GetType().Name}: {e.InnerException?.Message}");
}
Console.WriteLine($"failed task: status {failingTask.Status}");

// el trabajo de la tarea que falla
static void Fail() => throw new InvalidOperationException("test....");

Comentarios:

  • Líneas 10–16: cada tarea ejecuta una lambda que muestra el hilo que la ejecuta, duerme 0,5, 1 o 1,5 segundos y luego devuelve un resultado de tipo [int]. Por lo tanto, [Task.Run] devuelve un [Task<int>];
  • línea 20: el hilo principal espera a que terminen las tres tareas. Es una espera bloqueante, como [Join];
  • línea 24: la propiedad [Status] indica el estado de la tarea; [RanToCompletion] significa que terminó normalmente;
  • línea 24: la propiedad [Result] es el resultado de la tarea. Si la tarea no hubiera terminado, leer [Result] bloquearía el hilo hasta que terminara;
  • línea 28: una tarea que ejecuta el método [Fail], que lanza una excepción;
  • línea 32: la excepción lanzada en la tarea no se pierde: se almacena en el objeto [Task], y luego se vuelve a lanzar en el hilo que espera la tarea. [Wait] la envuelve en una [AggregateException] (una tarea puede agrupar varias de ellas), cuya propiedad [InnerException] es la excepción original;
  • línea 41: el método que lanza la excepción. Habríamos podido pasar la lambda [() => throw new InvalidOperationException(...)] directamente a [Task.Run].

Resultados:

> dotnet run threads-21.cs
Main thread: id 1, pool thread: False
11:37:39.970: task 0 runs in thread 4 (pool thread: True)
11:37:39.969: task 1 runs in thread 6 (pool thread: True)
11:37:40.516: task 2 runs in thread 4 (pool thread: True)
task 0: status RanToCompletion, result 0
task 1: status RanToCompletion, result 10
task 2: status RanToCompletion, result 20
AggregateException containing InvalidOperationException: test....
failed task: status Faulted
  • Las tareas se ejecutan en hilos del grupo (línea 3);
  • La tarea 2 no comenzó hasta que la tarea 0 hubo terminado, en el hilo que la tarea 0 había liberado: el grupo solo tenía 2 hilos (el mínimo predeterminado en esta máquina) y no creó un tercero a tiempo;
  • los resultados se obtienen después de que las tareas han terminado;
  • la excepción de la tarea que falló fue capturada por el hilo principal, y el estado de la tarea es [Faulted].

Este ejemplo también reemplaza al de la clase [BackgroundWorker] del curso de 2008, que mostraba cómo ejecutar un trabajo en segundo plano, obtener su resultado o su excepción, y cancelarlo. [BackgroundWorker] fue diseñada para interfaces gráficas de usuario de Windows Forms; ahora ha sido reemplazada por las tareas, con la cancelación gestionada mediante [CancellationToken] y el seguimiento del progreso mediante la interfaz [IProgress<T>], que se presentan en el capítulo siguiente junto con [async] / [await], que permiten esperar una tarea sin bloquear un hilo.

8.9.2. Parallel.For y Parallel.ForEach

La clase [System.Threading.Tasks.Parallel] (.NET 4) distribuye automáticamente las iteraciones de un bucle entre varios hilos del grupo:

  • [Parallel.For(start, end, i => ...)] ejecuta el cuerpo del bucle para i desde [start] hasta [end] - 1;
  • [Parallel.ForEach(collection, element => ...)] ejecuta el cuerpo del bucle para cada elemento de la colección;
  • un parámetro [ParallelOptions] permite limitar el número de iteraciones ejecutadas simultáneamente (propiedad [MaxDegreeOfParallelism]);
  • ambos métodos no devuelven el control hasta que todas las iteraciones han terminado. El hilo que los llama participa él mismo en el trabajo.

Estos bucles solo son adecuados si las iteraciones son independientes: su orden de ejecución no está definido y, si actualizan datos compartidos, esos datos deben protegerse. El programa [threads-22.cs] es el siguiente:

// la biblioteca paralela: Parallel.For y Parallel.ForEach

using System.Collections.Concurrent;
using System.Diagnostics;

// 1 - contar los números primos menores que N
const int N = 5_000_000;
// versión secuencial
var stopwatch = Stopwatch.StartNew();
int nbSequential = 0;
for (int i = 2; i < N; i++)
{
    if (IsPrime(i))
    {
        nbSequential++;
    }
}
Console.WriteLine($"sequential for    : {nbSequential:N0} prime numbers in {stopwatch.ElapsedMilliseconds} ms");

// versión paralela n.º 1: las iteraciones se reparten entre varios hilos
stopwatch.Restart();
int nbParallel1 = 0;
Parallel.For(2, N, i =>
{
    if (IsPrime(i))
    {
        // el contador es compartido: incremento atómico
        Interlocked.Increment(ref nbParallel1);
    }
});
Console.WriteLine($"Parallel.For no. 1: {nbParallel1:N0} prime numbers in {stopwatch.ElapsedMilliseconds} ms");

// versión paralela n.º 2: cada hilo cuenta en una variable local,
// que se suma al total compartido una sola vez, al final
stopwatch.Restart();
int nbParallel2 = 0;
// los hilos que trabajaron y el número de primos encontrados por cada uno
var threads = new ConcurrentDictionary<int, int>();
Parallel.For(2, N,
    // inicialización del contador local
    () => 0,
    // el cuerpo del bucle devuelve el nuevo valor del contador local
    (i, state, local) => IsPrime(i) ? local + 1 : local,
    // fin del trabajo de un hilo: sumamos su contador local al total
    local =>
    {
        Interlocked.Add(ref nbParallel2, local);
        threads.AddOrUpdate(Environment.CurrentManagedThreadId, local, (_, n) => n + local);
    });
Console.WriteLine($"Parallel.For no. 2: {nbParallel2:N0} prime numbers in {stopwatch.ElapsedMilliseconds} ms");
foreach (var (id, nb) in threads.OrderBy(pair => pair.Key))
{
    Console.WriteLine($"  thread {id}: {nb:N0} prime numbers found");
}

// 2 - procesar una colección con como máximo 2 procesamientos simultáneos
string[] files = ["a.txt", "b.txt", "c.txt", "d.txt", "e.txt"];
var options = new ParallelOptions { MaxDegreeOfParallelism = 2 };
Parallel.ForEach(files, options, file =>
{
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: processing of {file} in thread {Environment.CurrentManagedThreadId}");
    // procesamiento simulado
    Thread.Sleep(500);
});
Console.WriteLine("Parallel.ForEach finished");

// prueba de primalidad (deliberadamente simple)
static bool IsPrime(int n)
{
    if (n < 2)
    {
        return false;
    }
    for (int d = 2; d * d <= n; d++)
    {
        if (n % d == 0)
        {
            return false;
        }
    }
    return true;
}

Comentarios:

  • líneas 7–18: contamos los números primos menores que 5 000 000 mediante un bucle [for] estándar. La función [IsPrime] (líneas 68–81) prueba los divisores hasta la raíz cuadrada del número: es un proceso que consume mucho tiempo, y las iteraciones son independientes;
  • líneas 22–31: el mismo bucle con [Parallel.For]. El contador [nbParallel1] es compartido por todos los hilos: se incrementa mediante [Interlocked.Increment] (una variable local capturada por una lambda puede pasarse por referencia);
  • Líneas 36–50: una versión sobrecargada de [Parallel.For] permite trabajar con una variable local: [Parallel.For] descompone el bucle en tareas, cada una ejecutada por un solo hilo, y cada tarea tiene su propio contador. La primera lambda (41) inicializa el contador de una tarea; la segunda (43) es el cuerpo del bucle, que recibe el contador y devuelve su nuevo valor; la tercera (45) se ejecuta una vez por tarea, al final de su trabajo: suma el contador de la tarea al total compartido. Esto reduce significativamente el número de operaciones atómicas;
  • línea 48: para cada hilo que participó, registramos el número de números primos que encontró;
  • líneas 57–65: [Parallel.ForEach] procesa una colección de nombres de archivo (el procesamiento se simula con una pausa de medio segundo), con un máximo de 2 procesos simultáneos.

Resultados:

> dotnet run threads-22.cs
sequential for    : 348,513 prime numbers in 2061 ms
Parallel.For no. 1: 348,513 prime numbers in 2161 ms
Parallel.For no. 2: 348,513 prime numbers in 1928 ms
  thread 1: 112,640 prime numbers found
  thread 4: 118,169 prime numbers found
  thread 5: 36,754 prime numbers found
  thread 7: 80,950 prime numbers found
11:37:50.239: processing of c.txt in thread 7
11:37:50.239: processing of a.txt in thread 1
11:37:50.776: processing of d.txt in thread 7
11:37:50.776: processing of b.txt in thread 1
11:37:51.277: processing of e.txt in thread 7
Parallel.ForEach finished
  • Los tres bucles encuentran la misma cantidad de números primos;
  • varios hilos participaron en el bucle paralelo, incluido el hilo principal (ID 1);
  • el procesamiento de [Parallel.ForEach] ocurre de a pares, con medio segundo de diferencia, y en un orden que no coincide con el de la lista;
  • El ahorro de tiempo en esta ejecución es decepcionante: solo hay 2 procesadores, que los hilos de nuestro programa compartían con otros programas muy activos en el momento de la captura. En una máquina con poca carga y n procesadores, un bucle paralelo como este puede ser casi n veces más rápido que el bucle secuencial. Siempre se debe medir antes de sacar conclusiones: la paralelización tiene un costo (distribución del trabajo, sincronización) que solo vale la pena si cada iteración implica suficiente cálculo.

8.10. Datos locales de un hilo

8.10.1. El principio

Consideremos una aplicación de tres capas:

Image

Supongamos que la aplicación es multiusuario, como una aplicación web. Cada solicitud de usuario es atendida por un hilo. El ciclo de vida del hilo es el siguiente:

  • el hilo se crea u obtiene del grupo de hilos para atender la solicitud de un usuario;
  • si esta solicitud requiere datos, el hilo ejecuta un método de la capa [ui], que llama a un método de la capa [business], que a su vez llama a un método de la capa [dao];
  • el hilo devuelve la respuesta al usuario. Luego termina o se devuelve al grupo de hilos.

Durante el segundo paso, puede ser útil que el hilo tenga sus propios datos, es decir, datos no compartidos con otros hilos. Estos datos podrían, por ejemplo, pertenecer al usuario específico al que el hilo atiende y utilizarse en las diversas capas [ui, business, dao] sin pasarse como parámetro a cada método.

El curso de 2008 utilizaba los métodos [Thread.SetData] y [Thread.GetData] para este fin, que gestionan una especie de diccionario privado del hilo. Todavía existen, pero se usan poco; se prefieren dos herramientas más sencillas y eficientes:

  • el atributo [[ThreadStatic]] aplicado a un campo estático: cada hilo tiene su propia instancia del campo;
  • la clase [ThreadLocal<T>]: un objeto cuya propiedad [Value] tiene un valor distinto para cada hilo. Una función pasada al constructor proporciona el valor inicial para cada hilo.

El programa [threads-23.cs] compara un campo estático ordinario con estas dos herramientas:

// datos locales a un hilo: [ThreadStatic] y ThreadLocal<T>

Thread.CurrentThread.Name = "Main";
// el hilo principal escribe sus propios valores
Context.Shared = 100;
Context.PerThread = 100;
Context.User.Value = "admin";

// tres hilos escriben y luego releen los tres datos
var threads = new Thread[3];
for (int i = 0; i < threads.Length; i++)
{
    int number = i;
    threads[i] = new Thread(() =>
    {
        // escritura
        Context.Shared = number;
        Context.PerThread = number;
        // el hilo T2 no fija un usuario: obtendrá el valor predeterminado
        if (number != 2)
        {
            Context.User.Value = $"user{number}";
        }
        // dejamos que los otros hilos escriban a su vez
        Thread.Sleep(200);
        // relectura
        Display();
    })
    { Name = $"T{i}" };
    threads[i].Start();
}
foreach (Thread thread in threads)
{
    thread.Join();
}
// relectura por el hilo principal
Display();

// muestra los datos vistos por el hilo actual
static void Display()
{
    Console.WriteLine($"{Thread.CurrentThread.Name,-4} : Shared={Context.Shared,-3} PerThread={Context.PerThread,-3} WithInitializer={Context.WithInitializer,-2} User={Context.User.Value}");
}

// los datos del programa
static class Context
{
    // un campo estático ordinario: una sola copia, compartida por todos los hilos
    public static int Shared;
    // una copia por hilo
    [ThreadStatic]
    public static int PerThread;
    // trampa: el inicializador solo se ejecuta para el primer hilo que usa la clase
    [ThreadStatic]
    public static int WithInitializer = 5;
    // una copia por hilo, inicializada para cada hilo por la fábrica pasada al constructor
    public static readonly ThreadLocal<string> User = new(() => $"anonymous (thread {Thread.CurrentThread.Name})");
}

Comentarios:

  • línea 49: un campo estático ordinario. Solo existe una instancia, compartida por todos los hilos;
  • líneas 51–52: el atributo [[ThreadStatic]] da a cada hilo una instancia del campo;
  • líneas 54–55: una trampa clásica. El inicializador [= 5] lo ejecuta el constructor estático de la clase, una sola vez, en el hilo que usa la clase primero. Para los demás hilos, el campo tiene el valor predeterminado de su tipo, que en este caso es 0;
  • línea 57: un objeto [ThreadLocal<string>]. La lambda pasada al constructor se ejecuta la primera vez que un hilo lee [Value] sin haber escrito en él; proporciona el valor inicial para ese hilo;
  • Líneas 5–7: el hilo principal escribe sus propios valores;
  • líneas 17–22: cada hilo escribe sus propios valores, excepto el hilo T2, que no establece un usuario;
  • línea 25: cada hilo espera a que los demás escriban antes de volver a leer los valores.

Resultados:

1
2
3
4
5
> dotnet run threads-23.cs
T0   : Shared=2   PerThread=0   WithInitializer=0  User=user0
T2   : Shared=2   PerThread=2   WithInitializer=0  User=anonymous (thread T2)
T1   : Shared=2   PerThread=1   WithInitializer=0  User=user1
Main : Shared=2   PerThread=100 WithInitializer=5  User=admin
  • el campo ordinario [Shared] tiene el mismo valor para todos los hilos: el último valor escrito (en esta ejecución, el del hilo T2);
  • el campo [PerThread] conservó, en cada hilo, el valor que ese hilo había escrito en él;
  • el campo [WithInitializer] vale 5 para el hilo principal y 0 para los demás;
  • la propiedad [User.Value] tiene el valor escrito por cada hilo; el hilo T2, que no había escrito en ella, recibió el valor inicial proporcionado por la lambda del constructor.

Los datos locales de un hilo tienen una limitación: su ámbito es el hilo, no el proceso. Con la programación asíncrona, como se verá en el próximo capítulo, un mismo proceso puede comenzar en un hilo y continuar en otro después de una espera. En este caso, se utiliza la clase [AsyncLocal<T>], cuyo valor persiste entre hilos.

8.10.2. Aplicación: una transacción compartida entre capas

Consideremos la siguiente aplicación de tres capas, en la que la capa [dao] gestiona una tabla de artículos:

Image

Supongamos que la interfaz de la capa [dao] es inicialmente la siguiente:

1
2
3
4
5
6
interface IDao
{
    int InsertArticle(Article article);
    List<Article> GetAllArticles();
    void DeleteAllArticles();
}

Más adelante surge la necesidad de insertar un arreglo de artículos dentro de una transacción, porque el sistema debe operar bajo el principio de todo o nada: o se insertan todos los artículos, o ninguno. Se puede agregar a la interfaz un método llamado [InsertArticles(Article[] articles)]. Luego, para otra aplicación, surge la necesidad de eliminar una lista de artículos, de nuevo dentro de una transacción… Para satisfacer distintos requisitos de negocio, la capa [dao] irá creciendo. Podemos adoptar un enfoque diferente:

  • incluir solo las operaciones básicas (insertar, actualizar, eliminar, leer un artículo) en la capa [dao];
  • trasladar las operaciones que actualizan simultáneamente varios artículos a la capa [business]. Estas operaciones utilizan las operaciones básicas de la capa [dao].

La ventaja de esta solución es que la misma capa [dao] puede utilizarse sin modificaciones con distintas capas [business]. Esto introduce un desafío en la gestión de la transacción que agrupa las actualizaciones que deben realizarse de forma atómica:

  • la transacción debe ser iniciada por la capa [business] antes de que esta llame a los métodos de la capa [dao];
  • los métodos de la capa [dao] deben conocer la existencia de la transacción para poder participar en ella;
  • la transacción debe ser finalizada (confirmada o revertida) por la capa [business].

Para que los métodos de la capa [dao] conozcan cualquier transacción en curso, la transacción podría agregarse como parámetro a cada método de la capa [dao]. Este parámetro aparecería entonces en la firma de los métodos de la interfaz, lo que vincularía la interfaz a una fuente de datos específica. Los datos locales del hilo ofrecen una solución más elegante: la capa [business] coloca la transacción en los datos locales del hilo, y allí es donde la capa [dao] la recupera. No es necesario cambiar las firmas de los métodos de la capa [dao]. Varios hilos (varios usuarios) pueden trabajar simultáneamente: cada uno tiene su propia transacción.

El curso de 2008 utilizaba una base de datos SQL Server Compact, un producto que desde entonces fue descontinuado. Las bases de datos se tratarán en los capítulos sobre ADO.NET y Entity Framework Core. Para mantener el foco en los hilos, aquí utilizaremos una tabla en memoria y una transacción simulada. El programa [threads-24.cs] combina todas las capas en un solo archivo. Las entidades son las siguientes:

// un artículo
record Article(int Id, string Name, decimal Price, int CurrentStock, int MinimumStock);

// una transacción simulada: registra cómo deshacer cada actualización
class Transaction
{
    private static int counter;
    private readonly Stack<Action> undos = new();
    public int Number { get; } = Interlocked.Increment(ref counter);

    // registra la operación que deshace una actualización
    public void Log(Action undo) => undos.Push(undo);
    // confirma la transacción: se conservan las actualizaciones
    public void Commit() => undos.Clear();
    // revierte la transacción: se deshacen las actualizaciones, de la última a la primera
    public void Rollback()
    {
        while (undos.TryPop(out Action? undo))
        {
            undo();
        }
    }
}

// los datos locales al hilo compartidos por las capas
static class ThreadContext
{
    // la transacción actual del hilo (null si no hay ninguna)
    public static readonly ThreadLocal<Transaction?> Transaction = new();
}
  • línea 60: un artículo es un [record] cuyo identificador [Id] es asignado por la capa [dao];
  • líneas 63–78: una transacción simulada. Cada actualización realizada dentro de la transacción registra la operación necesaria para deshacerla (método [Log]); [Commit] confirma la transacción ignorando estas operaciones; [Rollback] la revierte ejecutando las operaciones de reversión, de la última a la primera (de ahí la pila [Stack<Action>]). Una base de datos real funciona de manera similar, mediante un registro de transacciones;
  • línea 67: a cada transacción se le asigna un número único. Como las transacciones pueden ser creadas por varios hilos simultáneamente, el contador se incrementa de forma atómica;
  • líneas 84–87: los datos locales del hilo compartidos por las capas: la transacción actual del hilo, o [null] si no hay ninguna.

La capa [dao] es la siguiente:

// la capa [dao]: una tabla de artículos en memoria con una restricción de unicidad sobre el nombre
interface IDao
{
    int InsertArticle(Article article);
    List<Article> GetAllArticles();
    void DeleteAllArticles();
}

class Dao : IDao
{
    // la tabla, compartida por todos los hilos, y su bloqueo
    private readonly List<Article> table = [];
    private readonly Lock padlock = new();
    private int nextId = 1;

    public int InsertArticle(Article article)
    {
        // ¿hay una transacción en curso en el hilo actual?
        Transaction? transaction = ThreadContext.Transaction.Value;
        lock (padlock)
        {
            if (table.Any(a => a.Name == article.Name))
            {
                throw new InvalidOperationException($"an article named [{article.Name}] already exists");
            }
            Article inserted = article with { Id = nextId++ };
            table.Add(inserted);
            // dentro de una transacción, se registra cómo deshacer la inserción
            transaction?.Log(() =>
            {
                lock (padlock)
                {
                    table.Remove(inserted);
                }
            });
            string mode = transaction is null ? "outside a transaction" : $"in transaction {transaction.Number}";
            Console.WriteLine($"[{Thread.CurrentThread.Name}] [dao] insertion of {inserted.Name} (id {inserted.Id}) {mode}");
            return 1;
        }
    }

    public List<Article> GetAllArticles()
    {
        lock (padlock)
        {
            return [.. table];
        }
    }

    public void DeleteAllArticles()
    {
        lock (padlock)
        {
            table.Clear();
        }
    }
}
  • línea 101: la tabla de artículos, compartida por todos los hilos. El acceso a ella está protegido por el bloqueo de la línea 102;
  • línea 108: el método [InsertArticle] recupera cualquier transacción que la capa [business] haya colocado en los datos locales del hilo actual;
  • Líneas 111–113: la tabla tiene una restricción de unicidad sobre los nombres de los artículos: insertar un artículo con un nombre que ya existe lanza una excepción;
  • Línea 115: el artículo insertado es una copia del artículo recibido, con un identificador asignado por la capa [dao]. La expresión [with] crea una copia de un [record] modificando ciertas propiedades;
  • Líneas 118–122: si hay una transacción en curso, la capa [dao] participa registrando cómo deshacer la inserción. El operador [?.] llama a [Log] solo si [transaction] no es [null];
  • línea 125: un mensaje de traza muestra el hilo, el artículo insertado y la transacción, si existe;
  • líneas 131–135: la lista de artículos devuelta es una copia de la tabla (expresión de colección [.. table]), de modo que quien llama no la recorra mientras otro hilo la modifica.

La capa [business] es la siguiente:

// la capa [business]
interface IBusiness
{
    void InsertArticlesInTransaction(Article[] articles);
    void InsertArticlesOutOfTransaction(Article[] articles);
    List<Article> GetAllArticles();
    void DeleteAllArticles();
}

class Business(IDao dao) : IBusiness
{
    // inserción de un arreglo de artículos: todo o nada
    public void InsertArticlesInTransaction(Article[] articles)
    {
        // inicio de la transacción, almacenada en los datos locales del hilo
        var transaction = new Transaction();
        ThreadContext.Transaction.Value = transaction;
        try
        {
            foreach (Article article in articles)
            {
                // la capa [dao] encontrará la transacción en el hilo
                dao.InsertArticle(article);
                // procesamiento simulado, que da tiempo a otros hilos para intervenir
                Thread.Sleep(200);
            }
            transaction.Commit();
            Console.WriteLine($"[{Thread.CurrentThread.Name}] [business] transaction {transaction.Number} committed");
        }
        catch
        {
            transaction.Rollback();
            Console.WriteLine($"[{Thread.CurrentThread.Name}] [business] transaction {transaction.Number} rolled back");
            throw;
        }
        finally
        {
            // el hilo ya no tiene una transacción en curso
            ThreadContext.Transaction.Value = null;
        }
    }

    // inserción de un arreglo de artículos sin transacción
    public void InsertArticlesOutOfTransaction(Article[] articles)
    {
        foreach (Article article in articles)
        {
            dao.InsertArticle(article);
        }
    }

    public List<Article> GetAllArticles() => dao.GetAllArticles();
    public void DeleteAllArticles() => dao.DeleteAllArticles();
}
  • línea 157: la capa [dao] se inyecta mediante el constructor primario;
  • líneas 163–164: el método [InsertArticlesInTransaction] inicia una transacción y la guarda en los datos locales del hilo;
  • línea 170: se llama al método de inserción de la capa [dao] para cada artículo, sin pasarle la transacción;
  • línea 172: una pausa simula el procesamiento, con el fin de dar tiempo a otro hilo para intervenir durante la transacción (tercera parte del programa de prueba);
  • línea 174: si el programa llega a este punto, no se ha producido ninguna excepción: la transacción se confirma;
  • líneas 177–181: si se produce una excepción, la transacción se revierte y la excepción se vuelve a lanzar a quien llama;
  • línea 186: en cualquier caso, el hilo ya no tiene una transacción activa. Esto es importante si el hilo se reutiliza (hilo del grupo);
  • línea 191: la misma inserción, sin transacción.

El programa de prueba es el siguiente:

// datos locales a un hilo: la capa [business] coloca ahí la transacción, la capa [dao] la encuentra ahí

// las capas de la aplicación
IDao dao = new Dao();
IBusiness business = new Business(dao);
Thread.CurrentThread.Name = "Main";

// dos artículos con el mismo nombre: el segundo viola la restricción de unicidad sobre el nombre
Article[] articles = [new(0, "article", 100, 10, 1), new(0, "article", 100, 10, 1)];

// 1 - inserción fuera de una transacción
Console.WriteLine("Inserting the articles outside a transaction...");
Execute(() => business.InsertArticlesOutOfTransaction(articles));
DisplayArticles(business);

// 2 - inserción dentro de una transacción
business.DeleteAllArticles();
Console.WriteLine("Inserting the articles inside a transaction...");
Execute(() => business.InsertArticlesInTransaction(articles));
DisplayArticles(business);

// 3 - dos hilos simultáneos: la transacción del hilo A no es vista por el hilo B
business.DeleteAllArticles();
Console.WriteLine("Two simultaneous threads...");
Article[] articlesA = [new(0, "keyboard", 20, 5, 1), new(0, "mouse", 10, 5, 1), new(0, "keyboard", 20, 5, 1)];
Article[] articlesB = [new(0, "screen", 150, 2, 1)];
var threadA = new Thread(() => Execute(() => business.InsertArticlesInTransaction(articlesA))) { Name = "A" };
var threadB = new Thread(() => Execute(() => business.InsertArticlesOutOfTransaction(articlesB))) { Name = "B" };
threadA.Start();
Thread.Sleep(100);
threadB.Start();
threadA.Join();
threadB.Join();
DisplayArticles(business);

// ejecuta una acción, mostrando la posible excepción
static void Execute(Action action)
{
    try
    {
        action();
    }
    catch (Exception e)
    {
        Console.WriteLine($"[{Thread.CurrentThread.Name}] {e.GetType().Name} : {e.Message}");
    }
}

// muestra la lista de artículos
static void DisplayArticles(IBusiness business)
{
    Console.WriteLine("List of articles:");
    foreach (Article article in business.GetAllArticles())
    {
        Console.WriteLine($"  {article}");
    }
}
  • Línea 9: creamos un arreglo de dos artículos con el mismo nombre. La inserción del segundo artículo será rechazada. Si la inserción se realiza fuera de una transacción, el primer artículo se inserta y permanece en el arreglo. Si se realiza dentro de una transacción, el primer artículo se inserta y luego se elimina cuando la transacción se revierte;
  • Líneas 11–14: insertamos el arreglo fuera de una transacción y luego mostramos la tabla;
  • Líneas 16–20: el mismo proceso dentro de una transacción;
  • líneas 22–34: dos hilos trabajan simultáneamente. El hilo A inserta tres artículos dentro de una transacción (el tercero viola la restricción de unicidad); mientras tanto, el hilo B inserta un artículo fuera de una transacción;
  • líneas 37–45: la función [Execute] realiza una acción y muestra cualquier excepción, precedida del nombre del hilo.

Resultados:

> dotnet run threads-24.cs
Inserting the articles outside a transaction...
[Main] [dao] insertion of article (id 1) outside a transaction
[Main] InvalidOperationException : an article named [article] already exists
List of articles:
  Article { Id = 1, Name = article, Price = 100, CurrentStock = 10, MinimumStock = 1 }
Inserting the articles inside a transaction...
[Main] [dao] insertion of article (id 2) in transaction 1
[Main] [business] transaction 1 rolled back
[Main] InvalidOperationException : an article named [article] already exists
List of articles:
Two simultaneous threads...
[A] [dao] insertion of keyboard (id 3) in transaction 2
[B] [dao] insertion of screen (id 4) outside a transaction
[A] [dao] insertion of mouse (id 5) in transaction 2
[A] [business] transaction 2 rolled back
[A] InvalidOperationException : an article named [keyboard] already exists
List of articles:
  Article { Id = 4, Name = screen, Price = 150, CurrentStock = 2, MinimumStock = 1 }
  • La inserción fuera de la transacción dejó el primer registro en la tabla (línea 6);
  • la inserción realizada dentro de una transacción no dejó ningún registro en la tabla: el registro con ID 2 fue eliminado por la reversión;
  • En la tercera parte, el hilo B insertó la pantalla mientras la transacción 2 del hilo A estaba en curso: lo hizo fuera de la transacción, ya que la transacción es una variable local del hilo A. La reversión de la transacción 2 eliminó el teclado y el mouse insertados por A, pero no la pantalla insertada por B.

8.10.3. Conclusión

El ejemplo anterior demostró el valor de los datos locales del hilo para la gestión de transacciones. No debe replicarse tal cual. .NET proporciona este mecanismo de forma nativa con la clase [System.Transactions.TransactionScope]: una transacción «ambiental», accesible mediante [Transaction.Current], en la que las conexiones de base de datos participan automáticamente. Frameworks como Entity Framework Core también gestionan las transacciones sin que el código de la capa [dao] tenga que encargarse de ellas. Y en las aplicaciones web actuales, que son asíncronas, esta información de contexto la transporta [AsyncLocal<T>] en lugar de los datos locales del hilo.

8.11. Lecturas adicionales

La sincronización de hilos es un campo difícil. Este capítulo ha presentado las herramientas principales; para profundizar:

  • la documentación de Microsoft, capítulo «Threading in .NET»: Managed threading, en particular la página «Overview of synchronization primitives»;
  • la documentación de Microsoft, capítulo «Parallel Programming»: Parallel Programming in .NET, que cubre la biblioteca [Parallel], las tareas y las colecciones concurrentes;
  • el capítulo «Threading» del libro de Joseph Albahari, [C# in a Nutshell], cuya edición para C# 3.0 ya recomendaba el curso de 2008. Una versión más antigua pero todavía instructiva de este capítulo está disponible en línea: Threading in C#.

En el código moderno, rara vez se manipulan directamente objetos [Thread]. En su lugar, se prefieren las tareas ([Task]), ya que se ejecutan en el grupo de hilos, y sobre todo la programación asíncrona mediante las palabras clave [async] y [await], que permite esperar una operación de larga duración (acceso a la red, a una base de datos o a un archivo) sin bloquear un hilo. Este es el tema del próximo capítulo. No obstante, los conceptos tratados en este capítulo siguen siendo esenciales: las tareas se ejecutan en hilos, y los datos que comparten deben protegerse con las mismas herramientas ([lock], [Interlocked], colecciones concurrentes).