Skip to content

8. Threads de execução

Este capítulo apresenta a execução simultânea de várias partes de código em um mesmo programa: as threads (threads de execução) e as ferramentas usadas para sincronizá-las. Em 2008, a maioria das máquinas tinha apenas um processador, e o paralelismo era em grande parte uma ilusão mantida pelo sistema operacional. Hoje, até o laptop mais simples tem vários núcleos: várias threads de fato executam ao mesmo tempo, tornando os problemas de sincronização discutidos aqui ainda mais frequentes.

Os exemplos são aplicações de arquivo único ([dotnet run threads-01.cs]) localizadas na pasta [08-threads]. Observe que as diretivas [using] implícitas dessas aplicações incluem [System.Threading] e [System.Threading.Tasks]: as classes [Thread], [Lock], [Mutex], [Monitor], [Interlocked], [Task]… podem ser usadas sem a diretiva [using].

Um aviso antes de começar: os resultados de um programa com várias threads variam de uma execução para outra. A ordem em que as threads recebem o processador depende do sistema operacional, do número de processadores e da carga da máquina. Os resultados mostrados neste capítulo foram obtidos em uma máquina Linux com dois processadores, compartilhada com outros programas. Se você executar os exemplos, obterá resultados semelhantes, mas raramente idênticos.

8.1. A classe Thread

Quando uma aplicação é iniciada, ela é executada em um fluxo de execução chamado thread. A classe .NET que modela uma thread é a classe [System.Threading.Thread]. Seus principais construtores, propriedades e métodos são os seguintes:

Membro
Função
[Thread(ThreadStart start)]
cria uma thread que executará o método [start]. O delegate [ThreadStart] refere-se a um método sem parâmetros e sem valor de retorno: [void M()]
[Thread(ParameterizedThreadStart start)]
o mesmo que acima, mas com um método que tem um parâmetro do tipo [object?]: [void M(object? obj)]
[static Thread CurrentThread]
a thread que executa o código que solicitou essa propriedade
[string? Name]
o nome da thread, útil para acompanhamento
[int ManagedThreadId]
um identificador numérico único da thread
[bool IsBackground]
indica se a thread é uma thread em segundo plano (ver adiante)
[bool IsAlive]
indica se a thread está em execução no momento
[void Start()], [void Start(object? obj)]
inicia a execução da thread, opcionalmente passando a ela uma informação do tipo [object]
[void Join()], [bool Join(TimeSpan timeout)]
A thread T1, que executa [T2.Join()], fica bloqueada até que a thread T2 termine. A segunda forma limita a duração da espera
[static void Sleep(int ms)]
A thread que executa o método é suspensa por [ms] milissegundos. Ela perde a CPU, que é entregue a outra thread

O curso de 2008 também abordava o método [Abort], que encerrava uma thread à força. Na prática, ele não existe mais: desde o .NET Core, lança a exceção [PlatformNotSupportedException]. Interromper bruscamente uma thread podia deixar os dados que ela manipulava em um estado inconsistente. Hoje, pede-se a uma thread que pare de forma cooperativa, usando um token de cancelamento ([CancellationToken]) que a thread verifica regularmente: veremos isso no próximo capítulo.

Eis uma primeira aplicação que demonstra a existência de uma thread de execução principal — aquela que executa as instruções de nível superior do programa (o equivalente ao método [Main]). O programa [threads-01.cs] é o seguinte:

// a thread principal de um programa

// a thread que executa este código
Thread main = Thread.CurrentThread;
// no início, ela não tem nome
Console.WriteLine($"Name of the current thread: [{main.Name}]");
// damos um a ela
main.Name = "Main";
Console.WriteLine($"Name of the current thread: [{main.Name}]");
// algumas propriedades
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}");

// uma exibição a cada segundo
for (int i = 0; i < 5; i++)
{
    Console.WriteLine($"{main.Name}: {DateTime.Now:HH:mm:ss}");
    // a thread é suspensa por 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

Comentários:

  • Linha 4: obtém-se uma referência à thread que executa o programa;
  • Linhas 5–9: exibimos seu nome, o modificamos e o exibimos novamente. Inicialmente, a thread principal não tem nome (linha 2 dos resultados);
  • linhas 11–15: algumas propriedades da thread. A thread principal tem o ID 1; é uma thread em primeiro plano ([IsBackground] é igual a [False]) que não pertence ao pool de threads (falaremos desses dois conceitos mais adiante); ela está em execução no momento ([Running]);
  • Linha 16: a máquina que executou o exemplo tem 2 processadores;
  • linhas 19–23: um laço que exibe uma mensagem a cada segundo. [Thread.Sleep(1000)] suspende a thread principal por um segundo. O curso de 2008 usava aqui um laço infinito encerrado com Ctrl-C; nos limitamos a cinco exibições. Observe o formato [HH:mm:ss] (horas de 0 a 23): o curso de 2008 usava [hh], que exibe horas de 1 a 12.

8.2. Criação de threads de execução

É possível ter aplicações em que partes do código são executadas "simultaneamente" em diferentes threads de execução. Se a máquina tem menos processadores do que threads prontas para executar, as threads compartilham os processadores: cada uma usa um processador por vez durante um curto período (alguns milissegundos). Em uma máquina multiprocessada, várias threads de fato executam ao mesmo tempo. O tempo concedido a uma thread depende de vários fatores, entre eles sua prioridade, que tem um valor padrão, mas pode ser definida por programação (propriedade [Priority]). Uma thread que tem o processador pode liberá-lo antes do tempo:

  • ao esperar por um evento (término de outra thread com [Join], espera por um sinal);
  • ao entrar em estado de suspensão por um tempo determinado ([Sleep]).

Uma thread T é criada primeiro com um dos construtores apresentados acima, por exemplo:

Thread t = new Thread(Display);

onde [Display] é um método com uma das duas assinaturas a seguir:

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

Criar uma thread não a inicia:

  • a execução da thread T é iniciada por [T.Start()]: o método passado ao construtor de T é então executado pela thread T. O código que executa a instrução [T.Start()] não espera a thread T terminar; passa imediatamente à instrução seguinte. Temos então duas threads em execução paralela. Elas muitas vezes precisam se comunicar para acompanhar o andamento do trabalho compartilhado: esse é o problema da sincronização de threads;
  • Uma vez iniciada, a thread T executa de forma autônoma. Ela para quando o método que executa termina;
  • podemos esperar o término de sua execução com [T.Join()]. Trata-se de uma instrução bloqueante: a thread que a executa fica bloqueada até que a thread T conclua seu trabalho. Esse é um método básico de sincronização.

O programa [threads-02.cs] é o seguinte:

// criação de threads de execução

// damos um nome à thread principal
Thread.CurrentThread.Name = "Main";

// criação de 5 threads
var tasks = new Thread[5];
for (int i = 0; i < tasks.Length; i++)
{
    // a thread nº i executará o método Display
    tasks[i] = new Thread(Display);
    // damos um nome a ela
    tasks[i].Name = i.ToString();
    // iniciamos sua execução (operação não bloqueante)
    tasks[i].Start();
}

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

// o método executado pelas threads
static void Display()
{
    // a thread que executa o 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}");
    // dormimos por 1 s
    Thread.Sleep(1000);
    Console.WriteLine($"End of execution of the Display method in thread {current.Name}: {DateTime.Now:HH:mm:ss.fff}");
}

Comentários:

  • linha 4: damos um nome à thread principal;
  • linhas 7–15: 5 threads são criadas e iniciadas. Suas referências são armazenadas em um array para que possam ser recuperadas depois. Cada thread executa o método [Display] das linhas 22–29;
  • linha 11: o nome do método [Display] é convertido automaticamente em um delegate do tipo [ThreadStart] (os delegates foram apresentados no capítulo anterior);
  • linha 15: a thread nº i é lançada. Essa operação não é bloqueante: a thread nº i executa em paralelo com a thread principal que a lançou;
  • linha 19: a thread principal chega ao fim do programa;
  • linhas 22–29: o método [Display] exibe o nome e o ID da thread que o executa, bem como os horários de início e fim (em milissegundos) da execução;
  • linha 28: qualquer thread que execute o método [Display] faz uma pausa de 1 segundo. O processador é então entregue a outra thread que o aguarda. Ao fim da pausa de 1 segundo, a thread pausada volta a ser elegível para o processador. Ela o obterá quando chegar a sua vez.

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

Esses resultados são muito instrutivos:

  • Primeiro, vemos que lançar uma thread não é bloqueante. A thread principal lançou 5 threads e chegou ao fim do programa (linha 4) mesmo que três das threads lançadas ainda não tivessem exibido sua primeira mensagem;
  • a ordem de execução das threads é imprevisível: nesta execução, as threads 2 e 4 exibiram suas mensagens de início antes da thread 0. O sistema operacional tem aqui 6 threads e 2 processadores; ele distribui os processadores entre essas threads segundo suas próprias regras;
  • Notamos também que a ordem das exibições nem sempre segue a ordem dos horários exibidos: o horário é calculado antes de ser exibido e, nesse meio-tempo, outra thread pode ter escrito no console. [Console.WriteLine] é thread-safe: duas linhas escritas por duas threads não se misturam, mas sua ordem não é garantida;
  • cada thread faz uma pausa de um segundo com [Sleep] e depois conclui a execução do método [Display];
  • Por fim, o programa não parou quando a thread principal terminou seu trabalho: o processo esperou o término das 5 threads. Isso ocorre porque essas threads são threads em primeiro plano: um processo .NET termina quando todas as suas threads em primeiro plano terminaram.

Inversamente, uma thread pode ser declarada em segundo plano definindo sua propriedade [IsBackground] como [true] antes de lançá-la. As threads em segundo plano não impedem o processo de terminar: quando a última thread em primeiro plano termina, elas são interrompidas. O programa [threads-03.cs] é o seguinte:

// threads em segundo plano

// damos um nome à thread principal
Thread.CurrentThread.Name = "Main";

// criação de 5 threads em segundo plano
var tasks = new Thread[5];
for (int i = 0; i < tasks.Length; i++)
{
    tasks[i] = new Thread(Display)
    {
        Name = i.ToString(),
        // uma thread em segundo plano não impede o término do processo
        IsBackground = true
    };
    tasks[i].Start();
}

// damos tempo às threads para iniciarem
Thread.Sleep(100);
// fim da thread principal, portanto do processo
Console.WriteLine($"End of thread {Thread.CurrentThread.Name} at {DateTime.Now:HH:mm:ss.fff}");

// o método executado pelas threads
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}");
    // dormimos por 1 s
    Thread.Sleep(1000);
    Console.WriteLine($"End of execution of the Display method in thread {current.Name}: {DateTime.Now:HH:mm:ss.fff}");
}

Comentários:

  • linha 14: as 5 threads são threads em segundo plano. As propriedades [Name] e [IsBackground] são definidas por meio de um inicializador de objeto;
  • linha 20: a thread principal espera 100 ms para dar tempo às threads de iniciar e depois 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

As 5 threads começaram a execução e depois a thread principal terminou (linha 7). As threads em segundo plano foram então interrompidas durante sua suspensão de um segundo: nenhuma mensagem de fim é exibida. O curso de 2008 obtinha o mesmo resultado terminando [Main] com [Environment.Exit(0)], uma instrução que interrompe todas as threads da aplicação, e não apenas a que a executa. As threads do pool de threads, das quais falaremos adiante, são threads em segundo plano.

Se a thread principal quiser esperar o término das threads que criou, ela usa o método [Join]. O programa [threads-04.cs] também demonstra outra forma de especificar o código que uma thread deve executar: um lambda.

// espera pelo fim de uma thread com Join - threads criadas com uma lambda

// damos um nome à thread principal
Thread.CurrentThread.Name = "Main";

// criação de 5 threads
var tasks = new Thread[5];
for (int i = 0; i < tasks.Length; i++)
{
    // cópia local de i, capturada pela lambda
    int number = i;
    // a thread executa a lambda, que chama Display com um parâmetro tipado
    tasks[i] = new Thread(() => Display(number, 1000 + 100 * number)) { Name = i.ToString() };
    tasks[i].Start();
}

// esperamos o fim de todas as threads
foreach (Thread task in tasks)
{
    // a thread principal fica bloqueada até o fim da thread [task]
    task.Join();
}
// fim da thread principal
Console.WriteLine($"End of thread {Thread.CurrentThread.Name} at {DateTime.Now:HH:mm:ss.fff}");

// o método executado pelas threads
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}");
    // dormir por [duration] milissegundos
    Thread.Sleep(duration);
    Console.WriteLine($"End of execution of task {number} in thread {Thread.CurrentThread.Name}: {DateTime.Now:HH:mm:ss.fff}");
}

Comentários:

  • Linha 13: a thread executa o lambda [() => Display(number, 1000 + 100 * number)]. Um lambda sem parâmetros e sem valor de retorno é compatível com o delegate [ThreadStart]. Essa sintaxe permite chamar um método com parâmetros tipados (aqui, dois [int]) em vez da assinatura imposta [void M(object? obj)];
  • Linha 11: o lambda usa uma cópia da variável de laço [i]. Isso é essencial: um lambda captura a variável, não seu valor. Em um laço [for], a variável [i] é única para todas as iterações; se o lambda usasse [i], uma thread que iniciasse tarde poderia ler o valor de [i] de uma iteração posterior, ou até o valor final 5. A variável [number], declarada dentro do corpo do laço, é, por outro lado, uma nova variável a cada iteração (a variável de um laço [foreach] também é nova a cada iteração, desde o C# 5);
  • linhas 18–21: a thread principal espera cada uma das threads. Ela fica primeiro bloqueada esperando a thread 0, depois a thread 1, e assim por diante. Ao sair do laço, as 5 threads que ela lançou terminaram;
  • linha 31: a tarefa nº i dorme por 1.000 + 100 × i milissegundos, de modo que as threads terminem em uma ordem conhecida.

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

A última linha mostra que a thread principal terminou depois das threads que havia lançado, no momento em que a última delas terminou.

8.3. As vantagens das threads

Agora que destacamos a existência de uma thread padrão — a que executa o programa principal — e sabemos criar threads adicionais, vamos considerar as vantagens das threads. Elas têm dois usos principais:

  • aproveitar todos os processadores da máquina em um cálculo demorado: o trabalho é dividido em partes atribuídas a diferentes threads. Faremos isso com a biblioteca [Parallel] no fim deste capítulo;
  • realizar várias tarefas simultaneamente, particularmente quando algumas delas consistem principalmente em esperar (por uma resposta da rede, uma leitura de disco ou uma entrada do usuário). É o caso das aplicações cliente/servidor da Internet, que abordaremos em um capítulo posterior.

Em uma aplicação cliente/servidor da Internet, um servidor localizado em uma máquina chamada S1 responde a solicitações de clientes localizados em máquinas remotas C1, C2, ..., Cn:

Image

Usamos todos os dias aplicações da Internet que seguem esse modelo: serviços web, e-mail, transferência de arquivos etc. No diagrama acima, o servidor S1 deve atender simultaneamente os clientes Ci. Tomando o exemplo de um servidor de arquivos, sabemos que uma transferência pode às vezes durar vários minutos. Está fora de questão que um único cliente monopolize o servidor por tanto tempo. Uma solução comum é o servidor criar tantas threads de execução quantos forem os clientes. Cada thread fica então responsável por atender um cliente específico:

Image

Na prática, o servidor usa um pool de threads com um número limitado de threads, como descrito adiante. Os servidores modernos vão um passo além: enquanto um cliente espera uma resposta da rede, nenhuma thread é reservada para ele. Isso é possível graças à programação assíncrona, tema do próximo capítulo.

8.4. Troca de informações entre threads

Nos exemplos anteriores, as threads executavam um método sem parâmetros. O construtor [Thread(ParameterizedThreadStart)] aceita um método com a assinatura [void M(object? obj)]. Isso permite passar informações à thread lançada:

t.Start(obj1);

lança a thread [t], que então executa o método associado a ela na construção, passando-lhe o parâmetro real [obj1]. O programa [threads-05.cs] é o seguinte:

// troca de informações entre threads

// damos um nome à thread principal
Thread.CurrentThread.Name = "Main";

// criação de 5 threads
var tasks = new Thread[5];
var data = new Data[5];
for (int i = 0; i < tasks.Length; i++)
{
    // a thread nº i executará o método Sleep(object?)
    tasks[i] = new Thread(Sleep) { Name = i.ToString() };
    // o objeto trocado com a thread: a thread que a inicia define Start e Duration
    data[i] = new Data { Start = DateTime.Now, Duration = i + 1 };
    // iniciamos a thread passando esse objeto a ela
    tasks[i].Start(data[i]);
}

// esperamos as threads uma após a outra
for (int i = 0; i < tasks.Length; i++)
{
    // espera pelo fim da thread nº i
    tasks[i].Join();
    // a thread nº i preencheu a propriedade End de seu 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");
}
// fim da thread principal
Console.WriteLine($"End of thread {Thread.CurrentThread.Name} at {DateTime.Now:HH:mm:ss}");

// o método executado pelas threads: assinatura void (object?)
static void Sleep(object? state)
{
    // recuperamos o parâmetro com seu tipo real
    if (state is not Data info)
    {
        return;
    }
    // dormir por Duration segundos
    Thread.Sleep(info.Duration * 1000);
    // a thread iniciada retorna um resultado à thread que a iniciou
    info.End = DateTime.Now;
}

// as informações trocadas entre a thread que inicia e a thread iniciada
class Data
{
    // definido pela thread que inicia
    public DateTime Start { get; init; }
    public int Duration { get; init; }
    // definido pela thread iniciada
    public DateTime End { get; set; }
}

Comentários:

  • Linhas 46–52: a informação passada às threads é um objeto [Data]. Há uma troca de informações em duas vias entre a thread que lança e a thread lançada. [Start] e [Duration] são propriedades [init]: só podem ser definidas quando o objeto é criado:
    • [Start]: o horário de início da execução da thread, definido pela thread que a lança;
    • [Duration]: duração, em segundos, da suspensão da thread lançada, definida pela thread que a lança;
    • [End]: horário de término da execução da thread, definido pela thread lançada;
  • linha 12: cada thread é associada ao método [Sleep] das linhas 32–42, cuja assinatura [void Sleep(object? state)] corresponde ao delegate [ParameterizedThreadStart];
  • linhas 14–16: um objeto [Data] é criado, armazenado no array [data] e depois passado ao método [Start], que lança a thread;
  • linhas 20–26: a thread principal espera o término de cada uma das threads que lançou, depois recupera o objeto [data[i]] da thread nº i e exibe seu conteúdo;
  • linha 35: o parâmetro recebido é do tipo [object?]; o filtro de padrão [state is not Data info] verifica seu tipo real e o armazena na variável tipada [info]. O curso de 2008 fazia uma conversão de tipo (cast) para [(Data)state], que lança uma exceção se o objeto não for do tipo esperado;
  • linha 40: a propriedade [Duration] do parâmetro define a duração da suspensão;
  • linha 42: a propriedade [End] do parâmetro é definida.

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 exemplo mostra que duas threads podem trocar informações:

  • a thread chamadora pode controlar a execução da thread chamada fornecendo-lhe informações;
  • a thread lançada pode devolver resultados à thread que a lançou.

Para que a thread chamadora saiba quando os resultados que espera estão disponíveis, ela precisa ser notificada quando a thread chamada terminar. Aqui, ela esperou o término da thread chamada usando o método [Join]. [Join] também garante que quaisquer escritas feitas pela thread chamada sejam visíveis para a thread que a espera. Veremos outras formas de sincronização mais adiante.

Com um lambda, não é mais necessário usar o tipo [object]: o lambda captura diretamente variáveis tipadas. As linhas 12–16 poderiam ser escritas assim:

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();

com um método [static void Sleep(Data data)] que não precisa mais verificar o tipo de seu parâmetro. Essa é a abordagem mais comum hoje.

8.5. Acesso concorrente a recursos compartilhados

8.5.1. Acesso concorrente não sincronizado

No parágrafo anterior, as informações eram trocadas apenas entre duas threads e em momentos bem específicos: era um exemplo clássico de passagem de parâmetros. Há outros casos em que as informações são compartilhadas por várias threads que podem querer lê-las ou atualizá-las ao mesmo tempo. Isso levanta a questão da integridade dessas informações. Suponha que a informação compartilhada seja uma estrutura S contendo várias informações I1, I2, ..., In:

  • uma thread T1 começa a atualizar a estrutura S: modifica o campo I1 e é interrompida antes de concluir a atualização completa da estrutura S;
  • uma thread T2 que obtém o processador lê então a estrutura S para tomar decisões. Ela lê uma estrutura em estado instável: alguns campos estão atualizados, outros não.

Essa situação é chamada de acesso concorrente a um recurso compartilhado — neste caso, a estrutura S. Muitas vezes é difícil de gerenciar. Vamos considerar o exemplo a seguir para ilustrar os problemas que podem surgir:

  • uma aplicação gerará n threads, onde n é passado como parâmetro;
  • o recurso compartilhado é um contador que deve ser incrementado por cada thread gerada;
  • ao final da aplicação, o valor do contador é exibido. Ele deveria, portanto, ser igual a n.

O programa [threads-06.cs] é o seguinte:

// acesso concorrente não sincronizado a um recurso compartilhado

// verificação do argumento: o número de threads a criar
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;
}

// criação e início das threads
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 pelo fim das threads
foreach (Thread thread in threads)
{
    thread.Join();
}
// exibição do contador
Console.WriteLine($"Number of threads generated: {Counter.Value}");
return 0;

// o recurso compartilhado
static class Counter
{
    // o contador de threads, compartilhado por todas as threads
    public static int Value { get; private set; }

    // o método executado por cada thread
    public static void Increment()
    {
        // leitura do contador
        int value = Value;
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {Thread.CurrentThread.Name} read the counter value: {value}");
        // espera: a thread perde o processador
        Thread.Sleep(1000);
        // incremento do contador
        Value = value + 1;
        Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {Thread.CurrentThread.Name} wrote the counter value: {Value}");
    }
}

Comentários:

  • Linhas 4–8: o número de threads é passado como argumento. A condição da linha 5 reúne todas as verificações: um argumento é obrigatório; ele é um inteiro ([int.TryParse]); e está entre 1 e 100 (padrão relacional [nbThreads is < 1 or > nbMaxThreads]). O programa retorna o código de saída 1 se ocorrer um erro e 0 caso contrário (linha 25);
  • linhas 28–43: o recurso compartilhado é a propriedade estática [Counter.Value]. O contador é encapsulado em uma classe estática, com o método [Increment] executado por cada thread. Uma instrução de nível superior não pode declarar um campo: por isso, os dados compartilhados pelas threads são membros estáticos de uma classe;
  • linha 37: o contador é lido;
  • linha 40: a thread faz uma pausa de 1 segundo. Ela perde, portanto, a CPU;
  • linha 42: o contador é incrementado.

A pausa de um segundo existe apenas para forçar a thread a perder o processador entre a leitura e a escrita do contador. Na prática, não há garantia de que uma thread não seja interrompida entre esses dois momentos, e em uma máquina multiprocessada duas threads podem até ler o contador exatamente ao mesmo tempo. A pausa de um segundo apenas sistematiza esse risco.

Para passar argumentos a uma aplicação de arquivo único, coloque-os depois 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

Olhando esses resultados, fica claro o que acontece:

  • Uma primeira thread lê o contador. Encontra 0. Faz uma pausa de 1 segundo e perde assim a CPU;
  • uma segunda thread também lê o valor do contador. Ele ainda é 0, pois a thread anterior ainda não o incrementou. Ela também faz uma pausa de 1 segundo;
  • em menos de um segundo, todas as 5 threads têm tempo de ler o valor 0;
  • ao acordar, elas incrementam o valor 0 que leram e todas escrevem o valor 1 no contador, como confirma a última linha (linha 12).

Poderíamos objetar que o exemplo é artificial. Então vamos remover o [Sleep] e usar o operador [++], que dá a ilusão de uma única instrução. O programa [threads-07.cs] é o seguinte:

// atualizações perdidas sem Sleep: counter++ não é atômico

// parâmetros: número de threads, número de incrementos por thread
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 o experimento três vezes
for (int attempt = 1; attempt <= 3; attempt++)
{
    Counter.Value = 0;
    // criação e início das threads
    var threads = new Thread[nbThreads];
    for (int i = 0; i < nbThreads; i++)
    {
        threads[i] = new Thread(() =>
        {
            for (int j = 0; j < nbIncrements; j++)
            {
                // ler, incrementar, escrever: três operações
                Counter.Value++;
            }
        });
        threads[i].Start();
    }
    // espera pelo fim das threads
    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}");
}

// o recurso compartilhado
static class Counter
{
    public static int Value;
}

Comentários:

  • Linhas 4–5: o número de threads (4 por padrão) e o número de incrementos feitos por cada thread (50 milhões por padrão) podem ser passados como argumentos. A expressão [args.Length > 0 && int.TryParse(args[0], out int n) ? n : 4] retorna o argumento se ele existir e for válido; caso contrário, retorna o valor padrão. O separador [_] torna a constante [50_000_000] legível;
  • linha 20: cada thread incrementa o contador compartilhado sem nenhuma pausa;
  • linha 38: desta vez, o contador é um campo;
  • linha 32: o formato [N0] exibe um inteiro com separador de milhares.

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

Dezenas de milhões de atualizações foram perdidas, e o número varia de um teste para outro. A operação de alto nível [Counter.Value++] é, na verdade, traduzida em várias instruções básicas do processador: ler o valor da memória, incrementá-lo em um registrador e gravar o resultado na memória. Se duas threads leem o mesmo valor antes de uma delas gravar o seu, um incremento é perdido, exatamente como no exemplo anterior. São necessárias muitas iterações para observar isso: com um milhão de incrementos por thread, cada thread muitas vezes já terminou seu trabalho antes que a seguinte comece, e o resultado está correto. É isso que torna esses erros tão perigosos: um programa pode funcionar por meses e falhar justamente no dia em que o sistema está sob maior carga.

De onde vem o problema? Uma thread leu um valor desatualizado porque outra thread havia sido interrompida — ou trabalhava simultaneamente em outro processador — antes de concluir sua tarefa de atualizar o contador. Isso nos leva aos conceitos de recursos críticos e seções críticas em um programa:

  • um recurso crítico é um recurso que só pode ser mantido por uma thread por vez. Aqui, o recurso crítico é o contador;
  • uma seção crítica de um programa é uma sequência de instruções no fluxo de execução de uma thread durante a qual ela acessa um recurso crítico. Precisamos garantir que, durante essa seção crítica, a thread seja a única com acesso ao recurso.

No programa [threads-06.cs], a seção crítica é o código entre a leitura do contador e a gravação de seu novo valor:

1
2
3
4
5
6
// leitura do contador
int value = Value;
// espera: a thread perde o processador
Thread.Sleep(1000);
// incremento do contador
Value = value + 1;

Para executar esse código, é preciso garantir que a thread seja a única em execução. Ela pode ser interrompida, mas, durante essa interrupção, nenhuma outra thread deve poder executar esse mesmo código. A plataforma .NET oferece várias ferramentas para garantir acesso exclusivo a seções críticas de código. Veremos algumas delas agora.

8.5.2. A cláusula [lock] e o tipo [Lock]

A cláusula [lock] delimita uma seção crítica da seguinte forma:

1
2
3
4
lock (padlock)
{
    // seção crítica
}

[padlock] é um objeto visível a todas as threads que executam a seção crítica. A cláusula [lock] garante que apenas uma thread por vez execute a seção crítica: uma thread que encontra um lock mantido por outra thread fica bloqueada até que o lock seja liberado.

A partir do C# 13 e do .NET 9, o objeto de sincronização deve preferencialmente ser uma instância do tipo [System.Threading.Lock], projetado para essa finalidade. O exemplo anterior é reescrito da seguinte forma em [threads-08.cs]:

// seção crítica protegida pela cláusula lock e pelo tipo System.Threading.Lock (C# 13 / .NET 9)

// verificação do argumento: o número de threads a criar
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;
}

// criação e início das threads
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 pelo fim das threads, na ordem inversa de sua criação
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}");
}
// exibição do contador
Console.WriteLine($"Number of threads generated: {Counter.Value}");
return 0;

// o recurso compartilhado
static class Counter
{
    // o contador de threads
    public static int Value { get; private set; }
    // o objeto de sincronização, visível a todas as threads
    private static readonly Lock padlock = new();

    // o método executado por cada thread
    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");
        // apenas uma thread por vez executa o bloco a seguir
        lock (padlock)
        {
            // leitura do contador
            int value = Value;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} read the counter value: {value}");
            // espera: a thread perde o processador, mas mantém o lock
            Thread.Sleep(1000);
            // incremento do 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");
    }
}

Comentários:

  • linha 36: [padlock] é o objeto que permitirá sincronizar todas as threads. Ele é [readonly]: a referência nunca deve mudar; caso contrário, duas threads poderiam bloquear dois objetos diferentes;
  • Linhas 44–53: a seção crítica do método [Increment] é envolvida pela cláusula [lock]. A thread mantém o lock enquanto dorme por um segundo: as outras threads não podem entrar;
  • Linhas 20–24: a thread principal espera as threads na ordem inversa de sua criação.

Resultados com 3 threads:

> 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
  • As três threads solicitam entrada na seção crítica quase ao mesmo tempo;
  • apenas uma entra — neste caso, a thread 0 (a ordem de entrada não é garantida: não é necessariamente a primeira a chegar que entra primeiro). Ela lê o contador, dorme por um segundo, grava o novo valor e sai da seção crítica;
  • as outras duas threads ficam bloqueadas até que a primeira saia da seção crítica e depois prosseguem uma após a outra. Cada uma lê o valor gravado pela anterior;
  • a thread principal esperava o término da thread 2. Quando é notificada, ela espera a thread 1, que já terminou: é notificada imediatamente. O mesmo vale para a thread 0;
  • o número de threads está correto (linha 20).

O compilador traduz a cláusula [lock (padlock) { ... }] sobre um objeto [Lock] como:

1
2
3
4
using (padlock.EnterScope())
{
    // seção crítica
}

[EnterScope] adquire o lock e retorna uma estrutura cujo método [Dispose] — chamado ao sair do bloco [using] — libera o lock, mesmo que a seção crítica lance uma exceção. O tipo [Lock] também oferece os métodos [Enter], [TryEnter], e [Exit] para os casos em que o lock não pode ser gerenciado por um bloco.

Antes do .NET 9, e em muito código existente, o lock era um objeto genérico, tipicamente do tipo [object]:

1
2
3
4
5
6
private static readonly object synchro = new();
...
lock (synchro)
{
    // seção crítica
}

Essa forma continua válida: qualquer objeto .NET pode servir de lock. O compilador a traduz então em chamadas à classe [Monitor], que examinaremos mais adiante:

bool lockTaken = false;
try
{
    Monitor.Enter(synchro, ref lockTaken);
    // seção crítica
}
finally
{
    if (lockTaken) Monitor.Exit(synchro);
}

O tipo [Lock] é mais eficiente e torna a intenção explícita. Sempre bloqueamos um objeto privado: bloquear um objeto visível externamente ([this], um tipo com [typeof(...)], uma string) permitiria que código externo adquirisse o mesmo lock e bloqueasse o nosso.

8.5.3. A classe Mutex

A classe [System.Threading.Mutex] também permite delimitar seções críticas. Ela difere da cláusula [lock] quanto à visibilidade:

  • a cláusula [lock] sincroniza threads dentro de uma mesma aplicação;
  • a classe [Mutex] pode sincronizar threads de aplicações (ou processos) diferentes, se receber um nome.

Um [Mutex] é um objeto do sistema operacional: seu uso consome muito mais recursos que o de um [lock]. Para threads de um mesmo processo, preferimos portanto usar [lock]; [Mutex] é usado principalmente entre processos. Usaremos os seguintes construtores e métodos:

Membro
Função
[Mutex()]
cria um Mutex M anônimo, utilizável pelas threads do processo
[Mutex(bool initiallyOwned, string name)]
cria ou abre o mutex nomeado [name], compartilhado por todos os processos que usam esse nome
[bool WaitOne()]
A thread T1, que executa [M.WaitOne()], solicita a posse do mutex M. Se M não é mantido por nenhuma thread, ele é concedido a T1. Se uma thread T2 tenta então a mesma operação, ela fica bloqueada: um mutex só pode pertencer a uma thread. T2 será desbloqueada quando T1 liberar M. Assim, várias threads podem ficar bloqueadas esperando M
[bool WaitOne(TimeSpan timeout)]
O mesmo que acima, mas a espera é limitada a [timeout]. O método retorna [false] se o mutex não puder ser adquirido
[void ReleaseMutex()]
A thread que mantém M o libera. Uma das threads que esperam M o adquire então

A sincronização de uma seção crítica é feita da seguinte forma:

1
2
3
4
5
6
7
8
9
M.WaitOne();
try
{
    // a thread é a única a entrar aqui: seção crítica
}
finally
{
    M.ReleaseMutex();
}

Não se esqueça de liberar um mutex; caso contrário, as threads que o esperam ficarão bloqueadas indefinidamente. Por isso a liberação é feita em uma instrução [finally], que é executada independentemente de ter ocorrido uma exceção. O programa [threads-09.cs] retoma o exemplo anterior com um mutex:

// seção crítica protegida por um Mutex

// verificação do argumento: o número de threads a criar
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;
}

// criação e início das threads
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 pelo fim das threads
foreach (Thread thread in threads)
{
    thread.Join();
}
// exibição do contador
Console.WriteLine($"Number of threads generated: {Counter.Value}");
return 0;

// o recurso compartilhado
static class Counter
{
    // o contador de threads
    public static int Value { get; private set; }
    // o objeto de sincronização: um Mutex
    private static readonly Mutex synchro = new();

    // o método executado por cada thread
    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 a posse do Mutex
        synchro.WaitOne();
        try
        {
            // leitura do 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 do contador
            Value = value + 1;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} wrote the counter value: {Value}");
        }
        finally
        {
            // liberamos o Mutex, com ou sem exceção
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} leaves the critical section");
            synchro.ReleaseMutex();
        }
    }
}

Comentários:

  • linha 33: o objeto de sincronização das threads agora é um mutex;
  • linha 41: início da seção crítica. A thread fica bloqueada até que o mutex esteja livre;
  • linhas 42–57: como um mutex deve sempre ser liberado, ocorrendo ou não uma exceção, a seção crítica é colocada em um [try], cuja cláusula [finally] libera o mutex (linha 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

Os resultados são semelhantes aos anteriores: as threads passam pela seção crítica uma a uma, e o valor final do contador está correto.

O verdadeiro valor do mutex se revela com um mutex nomeado. O programa [threads-10.cs] é executado duas vezes, em dois processos diferentes, que compartilham uma seção crítica:

// um Mutex nomeado sincroniza threads de processos diferentes

// o nome do Mutex é conhecido por todos os processos que o usam
const string mutexName = @"Global\csharp-course-threads-10";
// o nome do processo é passado como argumento
string process = args.Length > 0 ? args[0] : "P";

// abrimos o Mutex nomeado (ele é criado se ainda não existir)
using var mutex = new Mutex(false, mutexName);
Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: process {process} requests the Mutex");
// tentativa sem espera
if (!mutex.WaitOne(TimeSpan.Zero))
{
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: the Mutex is held by another process, {process} waits");
    // espera sem limite de tempo
    mutex.WaitOne();
}
try
{
    // seção crítica entre processos
    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();
}

Comentários:

  • Linha 4: o nome do mutex. Todos os processos que abrem um mutex com esse nome usam o mesmo objeto do sistema. O prefixo [Global] especifica que o mutex é visível para todas as sessões da máquina (o prefixo padrão [Local] o limita à sessão do usuário);
  • Linha 9: o mutex nomeado é criado se ainda não existir; caso contrário, é aberto. O primeiro parâmetro, [false], indica que o processo não solicita a posse dele na criação. A declaração [using] libera o objeto [Mutex] ao final do programa;
  • linha 12: o processo tenta adquirir o mutex imediatamente ([TimeSpan.Zero]). Se falhar, informa a falha e depois o espera indefinidamente (linha 16);
  • Linhas 18–27: a seção crítica, que dura 3 segundos, seguida da liberação do mutex.

O script de captura lança o processo A, espera 1,5 segundo e depois lança o processo B. Resultados do processo 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 do processo 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

O processo B encontrou o mutex mantido pelo processo A e esperou. Ele o adquiriu no exato momento em que A o liberou. Um uso comum de um mutex nomeado é impedir que duas instâncias da mesma aplicação sejam iniciadas: a segunda instância, incapaz de adquirir o mutex, termina imediatamente. Se um processo termina sem liberar um mutex que mantém, diz-se que o mutex foi abandonado: o próximo processo a chamar [WaitOne] o adquire, mas lança a exceção [AbandonedMutexException] para sinalizar que o recurso protegido pode estar em um estado inconsistente.

8.5.4. A classe AutoResetEvent

Um objeto [AutoResetEvent] é uma barreira que deixa passar apenas uma thread por vez. Ele é construído da seguinte forma:

AutoResetEvent barrier = new AutoResetEvent(state);

O booleano [state] indica se a barreira está fechada ([false]) ou aberta ([true]). Uma thread que deseja passar pela barreira indica isso da seguinte forma:

barrier.WaitOne();
  • Se a barreira está aberta, a thread passa e a barreira se fecha automaticamente atrás dela (daí o nome da classe). Se várias threads esperam, apenas uma passa;
  • se a barreira está fechada, a thread fica bloqueada. Outra thread a abrirá no momento oportuno. Esse momento depende inteiramente do problema a ser resolvido. A barreira é aberta pela operação:
barrier.Set();

Uma thread também pode fechar uma barreira usando [barrier.Reset()]. Diferentemente de um mutex, uma barreira não pertence a nenhuma thread específica: qualquer thread pode abri-la. Se, no exemplo anterior, substituirmos o mutex por um [AutoResetEvent], o código fica assim [threads-11.cs]:

// seção crítica protegida por uma barreira AutoResetEvent

// verificação do argumento: o número de threads a criar
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;
}

// criação e início das threads
var threads = new Thread[nbThreads];
for (int i = 0; i < nbThreads; i++)
{
    threads[i] = new Thread(Counter.Increment) { Name = i.ToString() };
    threads[i].Start();
}
// deixamos as threads chegarem à barreira fechada
Thread.Sleep(500);
// abrimos a barreira da seção 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 pelo fim das threads
foreach (Thread thread in threads)
{
    thread.Join();
}
// exibição do contador
Console.WriteLine($"Number of threads generated: {Counter.Value}");
return 0;

// o recurso compartilhado
static class Counter
{
    // o contador de threads
    public static int Value { get; private set; }
    // a barreira, criada fechada (false)
    public static readonly AutoResetEvent Synchro = new(false);

    // o método executado por cada thread
    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");
        // passagem pela barreira: ela se fecha novamente atrás da thread
        Synchro.WaitOne();
        try
        {
            // leitura do 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 do contador
            Value = value + 1;
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} wrote the counter value: {Value}");
        }
        finally
        {
            // reabrimos a barreira para outra thread
            Console.WriteLine($"At {DateTime.Now:HH:mm:ss.fff}, thread {name} leaves the critical section");
            Synchro.Set();
        }
    }
}

Comentários:

  • linha 39: a barreira é criada em estado fechado. Ela será aberta pela thread principal na linha 23;
  • linha 19: a thread principal espera meio segundo para dar tempo às threads de chegar à barreira;
  • linha 47: a thread responsável por incrementar o contador solicita permissão para entrar na seção crítica. As várias threads se acumulam diante da barreira fechada. Quando a thread principal a abre, uma das threads em espera passa, e a barreira se fecha novamente;
  • linha 63: ao terminar seu trabalho, a thread reabre a barreira, permitindo que outra thread entre.

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

Os resultados são semelhantes aos anteriores. Vemos que as três threads esperam diante da barreira até que a thread principal a abra (linha 5).

8.5.5. As classes ManualResetEventSlim e SemaphoreSlim

Duas outras ferramentas de sincronização complementam as anteriores.

Um objeto [ManualResetEventSlim] é uma barreira que, uma vez aberta por [Set], permanece aberta e deixa passar todas as threads até ser explicitamente fechada por [Reset]. É o "sinal de largada" de uma corrida. O sufixo [Slim] designa as versões leves das ferramentas de sincronização, introduzidas com o .NET 4: elas só recorrem ao sistema operacional se a espera for prolongada e funcionam apenas dentro de um processo. O programa [threads-12.cs] é o seguinte:

// ManualResetEventSlim: uma barreira que deixa passar todas as threads em espera

// a barreira, criada fechada
using var start = new ManualResetEventSlim(false);

// criação e início de 4 threads
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 pela abertura da barreira
        start.Wait();
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: runner {name} has started");
    })
    { Name = i.ToString() };
    threads[i].Start();
}

// a thread principal espera 1 s e depois dá o sinal de partida
Thread.Sleep(1000);
Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: start signal");
// a barreira se abre e permanece aberta: todas as threads passam
start.Set();
// espera pelo fim das threads
foreach (Thread thread in threads)
{
    thread.Join();
}
Console.WriteLine($"Is the barrier open? {start.IsSet}");

Comentários:

  • linha 4: a barreira é criada em estado fechado;
  • linha 15: cada thread espera a abertura da barreira;
  • linha 26: a thread principal abre a barreira após um segundo;
  • linha 32: a propriedade [IsSet] indica se a barreira está aberta.

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

Os quatro corredores partiram juntos, ao milissegundo, após o sinal de largada. Com um [AutoResetEvent], apenas um teria partido.

Um semáforo é uma barreira dotada de um contador: ele permite que no máximo N threads entrem por vez em uma seção de código. Isso é útil para limitar o uso de um recurso disponível em quantidade limitada (conexões de banco de dados, solicitações simultâneas a um servidor etc.). O programa [threads-13.cs] é o seguinte:

// SemaphoreSlim: no máximo N threads por vez em uma seção de código

// um semáforo com 2 vagas
using var semaphore = new SemaphoreSlim(2);

// criação e início de 5 threads
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 uma vaga: bloqueante se não houver mais nenhuma
        semaphore.Wait();
        try
        {
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: thread {name} obtained a slot (free slots: {semaphore.CurrentCount})");
            // trabalho
            Thread.Sleep(1000);
        }
        finally
        {
            // devolvemos a vaga
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: thread {name} releases its slot");
            semaphore.Release();
        }
    })
    { Name = i.ToString() };
    threads[i].Start();
}
// espera pelo fim das threads
foreach (Thread thread in threads)
{
    thread.Join();
}

Comentários:

  • linha 4: o semáforo tem 2 vagas;
  • linha 15: uma thread solicita uma vaga. Se houver uma disponível, ela a ocupa e continua; caso contrário, fica bloqueada até que uma vaga fique disponível;
  • linha 18: o número de vagas ainda disponíveis;
  • linha 26: a thread devolve sua vaga, em uma 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

As cinco threads solicitam uma vaga; duas a obtêm imediatamente, enquanto as outras três esperam. Cada vez que uma thread libera sua vaga, uma thread em espera a obtém. Nunca há mais de duas threads na seção de código. Um semáforo de uma única vaga funciona como um lock. A classe [SemaphoreSlim] também tem um método [WaitAsync] que pode ser usado com [await], que veremos no próximo capítulo; a classe [Semaphore] (sem [Slim]), que consome mais recursos, pode — como [Mutex]—ser nomeada e compartilhada entre processos, mas apenas no Windows.

8.5.6. A classe Interlocked

A classe [Interlocked] torna operações simples sobre uma variável atômicas: a operação é executada por inteiro pela thread, sem que nenhuma outra thread possa observar ou modificar a variável no meio da operação. As ferramentas anteriores ([lock], [Mutex], [AutoResetEvent]) destinam-se todas a tornar atômico um grupo de operações, ao custo de bloquear outras threads. Para operações simples, porém frequentes, a classe [Interlocked] evita esse bloqueio usando instruções especiais do processador. Seus principais métodos estáticos são os seguintes:

Método
Função
[int Increment(ref int x)]
incrementa [x] em 1 e retorna o novo valor
[int Decrement(ref int x)]
decrementa [x] em 1 e retorna o novo valor
[int Add(ref int x, int value)]
soma [value] a [x] e retorna o novo valor
[int Exchange(ref int x, int value)]
atribui [value] a [x] e retorna o valor antigo
[int CompareExchange(ref int x, int value, int comparand)]
atribui [value] a [x] somente se [x] for igual a [comparand]; retorna o valor anterior de [x]
[long Read(ref long x)]
lê atomicamente um valor de 64 bits (útil em um processador de 32 bits)

Esses métodos estão disponíveis para os tipos [int], [long], [uint], [ulong] e — no caso de [Exchange] e [CompareExchange] — para outros tipos. Os métodos [And] e [Or] (.NET 5) realizam atomicamente uma operação bit a bit "e" ou "ou". O parâmetro é passado por referência ([ref]): [Interlocked] deve operar sobre a própria variável, não sobre uma cópia. Por isso, a variável deve ser um campo ou uma variável local; uma propriedade não pode ser passada por referência.

O programa [threads-14.cs] parte do experimento do programa [threads-07.cs] e compara três formas de incrementar o contador compartilhado:

// a classe Interlocked: operações atômicas sem lock

using System.Diagnostics;

// parâmetros: número de threads, número de incrementos por thread
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}");

// três maneiras de incrementar o contador compartilhado
Measure("without synchronization", Counter.WithoutSynchronization);
Measure("with lock", Counter.WithLock);
Measure("with Interlocked", Counter.WithInterlocked);

// inicia as threads que executam todas [increment] nbIncrements vezes
void Measure(string method, Action increment)
{
    Counter.Value = 0;
    // uma barreira para que todas as threads comecem ao mesmo tempo
    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();
    }
    // já!
    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");
}

// o recurso compartilhado
static class Counter
{
    // um campo (e não uma propriedade) para que possa ser passado por referência
    public static int Value;
    private static readonly Lock padlock = new();

    // ler, incrementar, escrever: não atômico
    public static void WithoutSynchronization() => Value++;

    // seção crítica protegida por um lock
    public static void WithLock()
    {
        lock (padlock)
        {
            Value++;
        }
    }

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

Comentários:

  • linha 3: a classe [Stopwatch], que mede durações, está no namespace [System.Diagnostics];
  • linhas 11–13: a função local [Measure] é chamada com três métodos de incremento diferentes, passados como um delegate [Action];
  • linhas 16–42: a função [Measure] lança [nbThreads] threads, cada uma das quais chama o método recebido [nbIncrements] vezes, e mede o tempo total com um [Stopwatch]. O formato [{Counter.Value,12:N0}] alinha o valor à direita em 12 caracteres;
  • linhas 20–26 e 36: as threads esperam todas atrás de uma barreira [ManualResetEventSlim], que se abre depois que todas foram lançadas. Isso permite que comecem seu trabalho simultaneamente, tornando o acesso concorrente muito mais provável do que com threads lançadas uma após a outra;
  • linha 49: o contador é um campo, e não uma propriedade, para que possa ser passado por referência a [Interlocked.Increment];
  • linha 53: o incremento não sincronizado;
  • linhas 56–60: incremento dentro de uma seção crítica protegida por um [Lock];
  • linha 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
  • Sem sincronização, o resultado está incorreto, mais uma vez;
  • os outros dois métodos produzem o resultado correto;
  • [Interlocked] é significativamente mais rápido que [lock] nesta execução. O lock é caro aqui porque quatro threads disputam constantemente o mesmo lock por uma operação minúscula. Os tempos medidos dependem muito da máquina e de sua carga: apenas sua ordem de grandeza é significativa.

O método [CompareExchange] é o elemento básico dos algoritmos "lock-free": lê-se o valor, calcula-se o novo e só então o grava, se a variável não tiver mudado nesse meio-tempo; caso contrário, recomeça-se. As coleções concorrentes apresentadas mais adiante o utilizam amplamente.

8.6. Acesso concorrente a vários recursos compartilhados

8.6.1. Deadlock

Em nossos exemplos anteriores, um único recurso era compartilhado entre as várias threads. A situação se complica se houver vários recursos e eles dependerem uns dos outros. Em particular, pode ocorrer um deadlock: duas threads esperam uma pela outra. Considere as seguintes ações, que ocorrem sequencialmente:

  • uma thread T1 adquire o lock V1 para acessar um recurso compartilhado R1;
  • uma thread T2 adquire o lock V2 para acessar um recurso compartilhado R2;
  • a thread T1 solicita o lock V2. Ela fica bloqueada;
  • a thread T2 solicita o lock V1. Ela fica bloqueada.

As threads T1 e T2 esperam uma pela outra indefinidamente. Várias soluções são possíveis:

  • solicitar os dois recursos ao mesmo tempo com um único lock. Isso nem sempre é possível se resultar em um bloqueio longo de um recurso custoso;
  • sempre adquirir os locks na mesma ordem: se todas as threads adquirem V1 antes de V2, o deadlock é impossível. Essa é a regra mais usada;
  • uma thread que mantém V1 e não consegue adquirir V2 libera V1 para evitar o deadlock.

O programa [threads-15.cs] provoca um deadlock e implementa a última solução:

// deadlock: duas threads pegam dois locks em ordem diferente

// os dois recursos compartilhados e seus locks
Lock lockR1 = new();
Lock lockR2 = new();

// T1 pega R1 e depois solicita R2; ela desiste após 2 s
var t1 = new Thread(() => Work(lockR1, "R1", lockR2, "R2", TimeSpan.FromSeconds(2))) { Name = "T1" };
// T2 pega R2 e depois solicita R1; ela espera até 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");

// pega o 1º recurso e depois tenta pegar o 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 tempo à outra thread para pegar seu primeiro recurso
        Thread.Sleep(500);
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} requests {secondName}");
        // solicitação com tempo máximo de espera, em vez de um lock que esperaria 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");
        }
    }
}

Comentários:

  • linhas 4–5: os locks dos dois recursos. Aqui são variáveis locais, capturadas pelos lambdas das linhas 8–10;
  • linha 8: a thread T1 adquire R1 e depois solicita R2; ela espera no máximo 2 segundos;
  • Linha 10: a thread T2 pega R2 e depois solicita R1 — ou seja, na ordem inversa; ela espera no máximo 5 segundos;
  • Linha 21: a thread adquire seu primeiro recurso;
  • linha 25: ela espera meio segundo, o que dá tempo à outra thread de adquirir seu próprio primeiro recurso: o deadlock é então certo;
  • linha 28: em vez de um [lock] que esperaria indefinidamente, a thread solicita o segundo lock com um tempo máximo de espera. [TryEnter] retorna [true] se o lock foi adquirido, ou [false] se o tempo limite expirou;
  • linha 36: um lock adquirido por [TryEnter] deve ser liberado por [Exit], dentro de uma cláusula [finally];
  • Linhas 39–41: se o segundo lock não pôde ser adquirido, a thread desiste. Ao sair do bloco [lock], ela libera seu primeiro 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 uma das duas threads adquiriu seu primeiro recurso e depois solicitou o segundo: estão em deadlock. Após 2 segundos, T1 desiste e libera R1; T2, que ainda esperava, obtém imediatamente R1 e pode fazer seu trabalho. Sem um tempo de espera, o programa nunca teria terminado.

8.6.2. Um exemplo: leitores e escritores

Considere o exemplo a seguir:

  • temos um array no qual algumas threads escrevem dados (os escritores) e outras os leem (os leitores);
  • os escritores são iguais entre si, mas exclusivos: apenas um escritor por vez pode depositar dados no array;
  • os leitores são iguais entre si, mas exclusivos: apenas um leitor por vez pode ler os dados armazenados no array;
  • um leitor só pode ler dados do array quando um escritor os colocou ali, e um escritor só pode colocar novos dados no array quando os dados que já estão ali foram lidos por um leitor.

Há dois tipos de recursos compartilhados:

  • o array em escrita: apenas um escritor por vez pode acessá-lo;
  • o array em leitura: apenas um leitor por vez pode acessá-lo.

e uma ordem de uso desses recursos:

  • um leitor deve sempre vir depois de um escritor;
  • um escritor deve sempre vir depois de um leitor, exceto na primeira vez.

O acesso a esses dois recursos pode ser controlado por duas barreiras do tipo [AutoResetEvent]:

  • a barreira [canWrite] controla o acesso dos escritores ao array;
  • a barreira [canRead] controla o acesso dos leitores ao array;
  • a barreira [canWrite] é criada aberta, permitindo que o primeiro escritor passe e bloqueando todos os outros;
  • A barreira [canRead] é criada no estado fechado, bloqueando todos os leitores;
  • quando um escritor termina seu trabalho, ele abre a barreira [canRead] para deixar um leitor passar;
  • quando um leitor termina seu trabalho, ele abre a barreira [canWrite] para deixar um escritor passar.

O programa [threads-16.cs] que ilustra essa sincronização é o seguinte:

// leitores e escritores sincronizados por duas barreiras AutoResetEvent

// o número de threads de cada tipo
const int nbThreads = 2;

// criação e início das threads leitoras
for (int i = 0; i < nbThreads; i++)
{
    new Thread(Board.Read) { Name = $"R{i}" }.Start();
}
// criação e início das threads escritoras
for (int i = 0; i < nbThreads; i++)
{
    new Thread(Board.Write) { Name = $"W{i}" }.Start();
}
// fim de Main: as outras threads continuam seu trabalho
Console.WriteLine("End of Main...");

// o recurso compartilhado e sua sincronização
static class Board
{
    // o array compartilhado entre leitores e escritores
    private static readonly int[] data = new int[3];
    // sinaliza que o conteúdo de data pode ser lido: fechada no início
    private static readonly AutoResetEvent canRead = new(false);
    // sinaliza que data pode ser escrito: aberta no início
    private static readonly AutoResetEvent canWrite = new(true);

    // ler o conteúdo do array
    public static void Read()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"Method [Read] started by thread {name}");
        // esperamos a permissão de leitura
        canRead.WaitOne();
        // leitura do array
        for (int i = 0; i < data.Length; i++)
        {
            // espera de 0,5 s: a thread perde o processador
            Thread.Sleep(500);
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: reader {name} read the number {data[i]}");
        }
        // permitimos um escritor
        canWrite.Set();
        Console.WriteLine($"Method [Read] finished by thread {name}");
    }

    // escrever no array
    public static void Write()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"Method [Write] started by thread {name}");
        // esperamos a permissão de escrita
        canWrite.WaitOne();
        // escrita do array
        for (int i = 0; i < data.Length; i++)
        {
            // espera de 0,5 s
            Thread.Sleep(500);
            // Random.Shared pode ser usado por várias threads
            data[i] = Random.Shared.Next(0, 1000);
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: writer {name} wrote the number {data[i]}");
        }
        // permitimos um leitor
        canRead.Set();
        Console.WriteLine($"Method [Write] finished by thread {name}");
    }
}

Comentários:

  • linhas 7–14: criação e início de duas threads leitoras, seguidas de duas threads escritoras. Nenhuma referência às threads é mantida: a thread principal não espera por elas;
  • linha 17: a thread principal termina imediatamente. O processo continua até que as quatro threads (que são threads de primeiro plano) terminem;
  • linha 23: o array [data] é o recurso compartilhado entre as threads leitoras e escritoras;
  • linha 25: a barreira [canRead] sinaliza aos leitores que eles podem ler o array. Ela é aberta pelo escritor que preencheu o array. É criada no estado fechado: um escritor precisa primeiro preencher o array;
  • linha 27: a barreira [canWrite] avisa aos escritores que eles podem escrever no array. Ela é aberta pelo leitor que leu o array inteiro. É criada no estado aberto: o array pode ser escrito desde o início;
  • linha 35: um leitor espera que um escritor sinalize que o array foi preenchido. Quando esse sinal chega, apenas um dos leitores em espera prossegue;
  • linhas 37–41: o array é lido, com uma pausa de meio segundo a cada elemento para forçar a thread a ceder a CPU;
  • linha 44: o leitor avisa aos escritores que o array foi lido e pode ser preenchido novamente;
  • o método [Write] é simétrico ao método [Read];
  • linha 61: os números escritos são gerados aleatoriamente. A propriedade [Random.Shared] (.NET 6) fornece um gerador compartilhado que pode ser usado com segurança por várias threads. O curso de 2008 compartilhava entre as threads um objeto [Random] comum, cujos métodos não foram projetados para serem chamados simultaneamente por várias threads.

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 destacar os seguintes pontos:

  • há apenas um leitor por vez, embora esse leitor perca o processador na seção crítica [Read];
  • há apenas um escritor por vez, embora ele perca o processador na seção crítica [Write];
  • um leitor só lê quando há algo para ler no array;
  • um escritor só escreve quando o array foi totalmente lido;
  • no entanto, a ordem de execução não pode ser controlada: não havia razão para o escritor W0 vir antes do escritor W1, nem para o leitor R0 vir antes do leitor R1. Uma outra execução pode resultar em uma ordem diferente.

8.6.3. A classe Monitor

No exemplo anterior, quando os escritores estão bloqueados na instrução [canWrite.WaitOne()], um deles (qualquer um) é desbloqueado pela operação [canWrite.Set()]. Se quisermos abrir a barreira para um escritor específico, as coisas se complicam.

Considere a analogia de uma repartição pública com guichês de atendimento. Quando um cliente chega, ele retira uma senha numerada no dispensador e depois vai se sentar. Os clientes são chamados pelo número, por um alto-falante. Enquanto espera, o cliente pode fazer o que quiser: ler ou cochilar. Ele é acordado cada vez que o alto-falante anuncia um número. Se for o seu número, o cliente se levanta e vai ao guichê; caso contrário, volta ao que estava fazendo. Podemos operar de maneira semelhante com threads. Tomemos o exemplo dos escritores:

No guichê
Com threads
vários escritores esperam pelo mesmo guichê
suas threads estão bloqueadas
o guichê fica disponível e o número do próximo escritor é chamado
a thread que estava lendo o array avisa aos escritores que o array está disponível. Essa thread, ou outra, determinou qual escritor deve prosseguir
Cada escritor verifica seu número; apenas aquele cujo número foi chamado vai ao guichê; os demais voltam para a fila de espera
Cada thread verifica se é a selecionada. Se for, ela atravessa a barreira; caso contrário, volta para a fila de espera

A classe [Monitor] implementa esse cenário. Seus métodos estáticos são os seguintes:

Método
Função
[Enter(object token)]
Solicita o token: a thread o obtém se ele estiver livre; caso contrário, fica bloqueada até que ele seja liberado
[bool TryEnter(object token, TimeSpan timeout)]
Igual ao anterior, com um tempo limite máximo
[Exit(object token)]
devolve o token
[bool Wait(object token)]
devolve o token e bloqueia a thread até que outra thread sinalize uma mudança por meio de [Pulse] ou [PulseAll]; a thread deve então recuperar o token antes de continuar
[Pulse(object token)]
acorda uma das threads bloqueadas por [Wait] nesse token
[PulseAll(object token)]
acorda todas as threads bloqueadas por [Wait] nesse token

Descreveremos agora um padrão clássico, proposto no capítulo “Threading” do livro de J. e B. Albahari, [C# in a Nutshell], capaz de resolver problemas de barreira com uma condição de entrada.

As threads que compartilham um recurso (o guichê) o acessam por meio de um objeto que chamaremos de token. Para atravessar a barreira que leva ao guichê, é preciso ter o token, e só existe um. As threads devem, portanto, passar o token umas às outras:

object token = new();

Para ir ao guichê, uma thread primeiro solicita o token com [Monitor.Enter(token)], ou, mais simplesmente, com uma cláusula [lock]. Se obtiver o token, ela verifica se atende à condição para ir ao guichê:

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

Se a thread não for a esperada no guichê, ela cede a vez devolvendo o token por meio de [Monitor.Wait(token)] e entra em estado bloqueado. Ela será acordada quando outra thread sinalizar uma mudança na condição de acesso; então recuperará o token e verificará a condição novamente. É por isso que a verificação é um laço ([while]) e não um simples [if]. A operação [Monitor.Wait(token)] só pode ser executada por uma thread que possua o token; caso contrário, uma exceção [SynchronizationLockException] é lançada. Nesse cenário, o token só é liberado depois que a operação é concluída.

A thread que modifica a condição de acesso ao guichê também deve possuir o token e avisar as threads em espera:

1
2
3
4
5
6
7
lock (token)
{
    // modificar a condição de acesso ao contador
    ...
    // acordar as threads que esperam pelo token
    Monitor.PulseAll(token);
}

Acordar as threads significa que as threads em espera se tornam candidatas ao token; elas não o recebem imediatamente. O token só fica disponível ao final do bloco [lock]. Todas as threads acordadas receberão então o token, uma de cada vez, em ordem indeterminada, tendo a oportunidade de verificar novamente a condição de acesso. A primeira que satisfizer a condição fica com o token e segue para o guichê.

Uma observação importante: os métodos [Wait], [Pulse] e [PulseAll] de [Monitor] se aplicam a um objeto bloqueado por [lock (obj)] ou [Monitor.Enter(obj)]. Eles não funcionam com o tipo [Lock] do .NET 9, que não tem equivalente. Os tokens deste parágrafo são, portanto, objetos do tipo [object].

De posse dessas informações, podemos reescrever a aplicação de leitores/escritores especificando a ordem em que leitores e escritores acessam seus respectivos guichês [threads-17.cs]:

// leitores e escritores indo ao contador em uma ordem imposta: Monitor.Wait / Monitor.PulseAll

// o número de threads de cada tipo
const int nbThreads = 3;

// a ordem dos leitores: o inverso da ordem de criação
Board.ReadOrder = [.. Enumerable.Range(0, nbThreads).Select(i => $"R{nbThreads - 1 - i}")];
// a ordem dos escritores: a ordem de criação
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}");
}

// criação e início das threads leitoras e depois das threads escritoras
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();
}

// permissão de escrita
Board.AllowWriting();
// fim de Main
Console.WriteLine("End of Main...");

// o recurso compartilhado e sua sincronização
static class Board
{
    // o array compartilhado entre leitores e escritores
    private static readonly int[] data = new int[3];
    // os tokens de acesso dos contadores de leitura e escrita
    private static readonly object canRead = new();
    private static readonly object canWrite = new();
    // as condições de acesso dos contadores
    private static bool readingAllowed = false;
    private static bool writingAllowed = false;
    private static int nextReader = 0;
    private static int nextWriter = 0;
    // a ordem dos leitores e dos escritores
    public static string[] ReadOrder { get; set; } = [];
    public static string[] WriteOrder { get; set; } = [];

    // abre o contador de escrita
    public static void AllowWriting()
    {
        lock (canWrite)
        {
            writingAllowed = true;
            // acordamos todos os escritores que esperam pelo token
            Monitor.PulseAll(canWrite);
        }
    }

    // ler o conteúdo do array
    public static void Read()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"Method [Read] started by thread {name}");
        // solicitamos o token do contador de leitura
        lock (canRead)
        {
            // enquanto não for a nossa vez, devolvemos o token e esperamos
            while (!readingAllowed || ReadOrder[nextReader] != name)
            {
                Monitor.Wait(canRead);
            }
            // no contador: leitura do array
            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]}");
            }
            // próximo leitor
            readingAllowed = false;
            nextReader++;
            // notificamos os escritores de que podem escrever
            lock (canWrite)
            {
                writingAllowed = true;
                Monitor.PulseAll(canWrite);
            }
            Console.WriteLine($"Method [Read] finished by thread {name}");
        }
    }

    // escrever no array
    public static void Write()
    {
        string name = Thread.CurrentThread.Name ?? "?";
        Console.WriteLine($"Method [Write] started by thread {name}");
        // solicitamos o token do contador de escrita
        lock (canWrite)
        {
            // enquanto não for a nossa vez, devolvemos o token e esperamos
            while (!writingAllowed || WriteOrder[nextWriter] != name)
            {
                Monitor.Wait(canWrite);
            }
            // no contador: escrita do array
            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]}");
            }
            // próximo escritor
            writingAllowed = false;
            nextWriter++;
            // notificamos os leitores de que podem ler
            lock (canRead)
            {
                readingAllowed = true;
                Monitor.PulseAll(canRead);
            }
            Console.WriteLine($"Method [Write] finished by thread {name}");
        }
    }
}

O acesso ao guichê de leitura é condicionado pelos seguintes elementos:

  • linha 36: o token [canRead];
  • linha 39: o booleano [readingAllowed];
  • linha 44: o array ordenado dos nomes dos leitores. Os leitores vão ao posto de leitura na ordem especificada por esse array;
  • linha 41: [nextReader] é o índice, nesse array, do próximo leitor autorizado a ir ao guichê.

O acesso ao guichê de escrita é controlado de forma semelhante pelo token [canWrite], o booleano [writingAllowed], o array [WriteOrder] e o índice [nextWriter].

O programa principal:

  • linhas 7–9: os leitores irão ao guichê na ordem inversa de sua criação (R2, R1, R0), e os escritores na ordem em que foram criados (W0, W1, W2). Os arrays são construídos com uma expressão de coleção [.. sequence], que cria um array a partir de uma consulta LINQ;
  • linhas 18–22: criação e inicialização dos leitores, seguidos dos escritores. Todos ficarão bloqueados, pois nem a leitura nem a escrita são permitidas;
  • linha 26: a escrita é habilitada, e os escritores são avisados de que algo mudou (método [AllowWriting], linhas 48–54).

O método [Read]:

  • linhas 64–86: todo o processo no posto de leitura é controlado por [lock] no token [canRead]. O leitor que o obtém o mantém durante toda a sua permanência no posto;
  • linhas 67–69: um leitor que adquiriu o token o devolve se a leitura não estiver autorizada ou se não for a sua vez;
  • linhas 72–75: passagem pelo posto (leitura da tabela);
  • linhas 78–79: o leitor altera as condições de acesso ao guichê de leitura. Ele ainda detém o token de leitura, e essas alterações impedem que qualquer outro leitor acesse o guichê;
  • linhas 81–84: o leitor altera as condições de acesso ao guichê de escrita e avisa todos os escritores em espera de que algo mudou. Para isso, ele pega o token [canWrite]: aqui vemos que a thread detém dois tokens ao mesmo tempo. Os escritores fazem o mesmo na ordem inversa (eles detêm [canWrite] e solicitam [canRead]), que é a situação de deadlock descrita anteriormente. No entanto, não há risco aqui: uma thread solicita o segundo token apenas ao final de sua passagem pelo guichê; os dois guichês nunca estão ocupados ao mesmo tempo; e as outras threads mantêm um token apenas pelo tempo necessário para verificar a condição de acesso, sem solicitar o outro token.

O método [Write] é simétrico ao método [Read]. O curso de 2008 usava, no programa principal, [Monitor.Pulse], que acorda apenas uma thread: se essa thread não fosse o escritor esperado, ela voltaria a dormir, e o escritor esperado poderia nunca ser acordado. Ao usar uma condição de acesso que especifica uma thread em particular, é preciso usar [PulseAll].

Eis um exemplo de execução:

> 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

Escritores e leitores se revezam em seus respectivos guichês, cada um na ordem especificada: W0, R2, W1, R1, W2, R0.

8.7. Coleções concorrentes

Os exemplos anteriores protegiam dados compartilhados muito simples (um contador, um array). Quando threads compartilham uma coleção (lista, dicionário, fila), poderíamos proteger cada acesso com um [lock]. Mas as coleções comuns ([List<T>], [Dictionary<TKey,TValue>], [Queue<T>]) não foram projetadas para serem modificadas por várias threads simultaneamente: o uso sem proteção pode causar perda de elementos, disparar exceções inesperadas ou até corromper a estrutura interna da coleção. A partir do .NET 4, o namespace [System.Collections.Concurrent] oferece coleções projetadas para serem compartilhadas entre threads sem bloqueio explícito:

Coleção
Função
[ConcurrentDictionary<TKey,TValue>]
um dicionário cujas operações, inclusive as atualizações condicionais, são seguras
[ConcurrentQueue<T>]
uma fila (primeiro a entrar, primeiro a sair)
[ConcurrentStack<T>]
uma pilha (último a entrar, primeiro a sair)
[ConcurrentBag<T>]
uma bolsa: uma coleção não ordenada
[BlockingCollection<T>]
um encapsulador das coleções anteriores que bloqueia o consumidor quando a coleção está vazia e, opcionalmente, o produtor quando ela está cheia

8.7.1. ConcurrentDictionary e ConcurrentQueue

No programa [threads-18.cs], quatro threads geram números aleatórios e contam o número de vezes que cada número aparece em um dicionário compartilhado:

// coleções concorrentes: ConcurrentDictionary e ConcurrentQueue

using System.Collections.Concurrent;

// o dicionário compartilhado: dígito -> número de sorteios
var draws = new ConcurrentDictionary<int, int>();
// a fila compartilhada dos relatórios das threads
var reports = new ConcurrentQueue<string>();

// 4 threads sorteiam cada uma 100.000 dígitos aleatórios
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);
            // adição da chave com o valor 1 ou atualização atômica do valor existente
            draws.AddOrUpdate(digit, 1, (key, oldValue) => oldValue + 1);
        }
        // relatório colocado na fila
        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();
}

// os relatórios, em sua ordem de chegada
while (reports.TryDequeue(out string? report))
{
    Console.WriteLine(report);
}
// os resultados dos sorteios
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: retorna o valor associado à chave, após adicioná-la se não existia
Console.WriteLine($"GetOrAdd(10, 0) = {draws.GetOrAdd(10, 0)}, number of keys: {draws.Count}");

Comentários:

  • linha 3: o namespace das coleções concorrentes;
  • linha 6: o dicionário compartilhado associa cada dígito ao seu número de ocorrências;
  • linha 8: uma fila na qual cada thread deposita um relatório ao final de seu trabalho;
  • linha 21: o método [AddOrUpdate] adiciona a chave [digit] com o valor 1 se ela não existir e, caso contrário, substitui seu valor pelo calculado pela função [(key, oldValue) => oldValue + 1]. A operação é atômica. Não poderíamos escrever [draws[digit]++]: essa expressão lê o valor e depois grava o novo, em duas operações, e duas threads poderiam perder uma atualização, como no exemplo [threads-07.cs];
  • linha 24: cada thread coloca seu relatório na fila;
  • linhas 35–37: a thread principal esvazia a fila. [TryDequeue] retorna [false] quando a fila está vazia. As coleções concorrentes oferecem apenas métodos “Try…” que combinam a verificação e a operação: uma verificação de [Count > 0] seguida de uma remoção não seria segura, pois outra thread poderia esvaziar a fila nesse intervalo;
  • linha 40: o dicionário é percorrido em ordem de chave; cada par chave/valor é decomposto em duas variáveis;
  • linha 46: o método [GetOrAdd] retorna o valor associado à chave, depois de adicionar a chave com o valor fornecido caso ela não existisse.

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

O número total de sorteios está correto: nenhuma atualização foi perdida. Os relatórios aparecem na ordem em que as threads concluíram seu trabalho.

8.7.2. Produtores e consumidores: BlockingCollection

O problema leitor-escritor é uma variante do clássico problema produtor-consumidor: threads produzem dados que outras threads consomem. A classe [BlockingCollection<T>] o resolve sem nenhuma ferramenta explícita de sincronização:

  • [Add(element)] adiciona um elemento. Se a coleção tiver capacidade limitada e estiver cheia, o produtor fica bloqueado até que uma vaga se abra;
  • [CompleteAdding()] sinaliza que nenhum outro elemento será adicionado;
  • [GetConsumingEnumerable()] retorna uma enumeração que remove os elementos um a um. Se a coleção estiver vazia, o consumidor fica bloqueado até que um elemento chegue; a enumeração termina quando a coleção está vazia e [CompleteAdding] foi chamado.

O programa [threads-19.cs] é o seguinte:

// produtor / consumidores com BlockingCollection<T>

using System.Collections.Concurrent;

// uma fila de no máximo 3 elementos
using var queue = new BlockingCollection<int>(boundedCapacity: 3);

// o produtor coloca 8 números e depois sinaliza que terminou
var producer = new Thread(() =>
{
    for (int i = 1; i <= 8; i++)
    {
        // bloqueante se a fila estiver cheia
        queue.Add(i);
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: P put {i} (waiting elements: {queue.Count})");
        Thread.Sleep(100);
    }
    // nenhum outro elemento será adicionado
    queue.CompleteAdding();
    Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: P has finished");
});

// dois consumidores pegam os números enquanto houver
var consumers = new Thread[2];
for (int i = 0; i < consumers.Length; i++)
{
    consumers[i] = new Thread(() =>
    {
        string name = Thread.CurrentThread.Name ?? "?";
        // a enumeração espera pelos elementos e para quando a fila está vazia e finalizada
        foreach (int number in queue.GetConsumingEnumerable())
        {
            Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} took {number}");
            // processamento do número
            Thread.Sleep(600);
        }
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff}: {name} has finished");
    })
    { Name = $"C{i + 1}" };
}

// início e espera de todas as threads
producer.Start();
foreach (Thread consumer in consumers)
{
    consumer.Start();
}
producer.Join();
foreach (Thread consumer in consumers)
{
    consumer.Join();
}

Comentários:

  • linha 6: uma fila (a coleção subjacente padrão é uma [ConcurrentQueue<int>]) contendo no máximo 3 elementos. O parâmetro é passado por nome, o que torna a chamada mais legível;
  • linhas 9–20: o produtor deposita os números de 1 a 8, um a cada décimo de segundo, e depois sinaliza que terminou;
  • linhas 24–37: dois consumidores recuperam os números e levam 0,6 segundo para processar cada um. Eles consomem os números mais lentamente do que o produtor os gera;
  • linha 31: a enumeração bloqueante. Cada número é recuperado por apenas um dos dois 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 o produtor enfileirar rapidamente os primeiros números e depois, assim que a fila contém 3 elementos, só enfileirar um número quando um consumidor retira um: ele fica bloqueado em [Add] quando a fila está cheia. Os consumidores dividem os números entre si e param quando a fila está vazia e o processo está concluído. Observe que o consumidor C2 exibiu a retirada do número 1 antes de o produtor exibir sua inserção: a inserção de fato ocorreu antes, mas o produtor foi interrompido entre [Add] e a sua exibição.

A classe [Channel<T>] no namespace [System.Threading.Channels] oferece o mesmo serviço para a programação assíncrona: um consumidor que espera por um elemento não bloqueia nenhuma thread. Trataremos disso no próximo capítulo.

8.8. O pool de threads

Até agora, para gerenciar threads, nós as criamos com [new Thread(...)] e depois as executamos com [Start()]. Criar uma thread é uma operação relativamente custosa: em particular, o sistema precisa alocar uma pilha para ela, e cada thread ocupa memória enquanto existir. Veremos no capítulo sobre bancos de dados que existem pools de conexões: conexões abertas são mantidas em reserva e emprestadas às threads que as solicitam, já que abrir uma conexão é custoso. Existe um sistema semelhante para threads: o pool de threads (ThreadPool) do .NET.

  • Enquanto o número de threads no pool estiver abaixo de um limite mínimo, o pool cria imediatamente uma nova thread para cada tarefa que não encontra uma thread livre. Por padrão, esse mínimo é o número de processadores; ele pode ser lido com [ThreadPool.GetMinThreads(out min1, out min2)] e alterado com [ThreadPool.SetMinThreads(min1, min2)]. O pool gerencia dois tipos de threads: threads de trabalho (min1), que executam os trabalhos que lhes são atribuídos, e threads de E/S assíncrona (min2);
  • se esse número for insuficiente, o pool cria threads adicionais de forma incremental, até um máximo que pode ser lido com [ThreadPool.GetMaxThreads(out max1, out max2)] e alterado com [ThreadPool.SetMaxThreads(max1, max2)]. Quando o máximo é atingido, os trabalhos atribuídos ao pool ficam na fila até que uma thread se torne disponível;
  • Uma thread que concluiu uma tarefa não é destruída: ela é devolvida ao pool e usada para a próxima tarefa.

O pool de threads oferece duas vantagens: economiza o tempo gasto na criação de threads (algumas threads podem atender centenas de requisições) e, ao limitar o número de threads, impede que a aplicação seja sobrecarregada por requisições em excesso.

Para atribuir uma tarefa ao pool, use o método [ThreadPool.QueueUserWorkItem(WaitCallback callback, object? state)], em que [WaitCallback] é um delegate com a assinatura [void M(object? state)]. A tarefa será executada por uma thread do pool, com o parâmetro [state]. O programa [threads-20.cs] é o seguinte:

// o pool de threads

// a thread principal
Thread.CurrentThread.Name = "Main";

// número mínimo de threads no pool
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 threads no pool
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 tarefas ao pool; a contagem regressiva nos permite esperar o fim delas
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 pelo fim das 7 tarefas
remainingJobs.Wait();
Console.WriteLine($"At {DateTime.Now:HH:mm:ss.ff}, end of the Main thread");

// a tarefa executada por uma thread do pool
void Sleep(object? state)
{
    if (state is not Data data)
    {
        return;
    }
    // estado do pool
    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})");
    // dormir por 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");
    // uma tarefa a menos
    remainingJobs.Signal();
}

// as informações passadas a cada tarefa
class Data
{
    public int Number { get; init; }
    public DateTime Start { get; init; }
    public int Duration { get; init; }
}

Comentários:

  • linhas 7–12: lemos e exibimos o número mínimo atual dos dois tipos de threads do pool e, em seguida, definimos o mínimo de threads de trabalho como 3. O parâmetro [out _] é um “parâmetro descartado”: não nos interessa o valor retornado;
  • linhas 14–19: fazemos o mesmo para definir o máximo de threads de trabalho como 5. [SetMaxThreads] retorna [false] se o valor solicitado for rejeitado, por exemplo, se for menor que o número de processadores;
  • linha 22: um objeto [CountdownEvent] funciona como uma contagem regressiva: cada chamada ao seu método [Signal] a decrementa, e seu método [Wait] bloqueia a thread chamadora até que ela chegue a 0. Aqui, ele permite que a thread principal espere o término dos 7 trabalhos: não é possível chamar [Join] em uma thread do pool, já que ela não pertence a você. O curso de 2008 pedia ao usuário que pressionasse [Enter] quando os trabalhos terminassem;
  • linhas 23–26: atribuímos ao pool 7 tarefas, cada uma com duração de 3 segundos, embora o pool nunca vá ter mais de 5 threads de trabalho. Cada tarefa recebe um objeto [Data];
  • linha 30: a thread principal espera o término dos 7 trabalhos;
  • linhas 34–48: a tarefa executada por uma thread do pool. Trata-se de uma função local não estática, porque ela usa a variável local [remainingJobs];
  • linha 41: o número de threads de trabalho ainda disponíveis (o máximo menos o número de threads ocupadas);
  • linha 48: o contador é decrementado ao final de cada trabalho.

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
  • Nesta máquina de dois processadores, o pool tinha inicialmente um mínimo de 2 threads de trabalho e um máximo de 32.767;
  • os trabalhos 0, 1 e 2 começaram imediatamente: o pool tem um mínimo de 3 threads;
  • os trabalhos 3 e 4 começaram com atrasos de um e dois segundos, respectivamente: não restavam threads livres e o pool, depois que ultrapassa seu mínimo, só cria novas threads gradualmente enquanto houver trabalhos esperando. O máximo de 5 threads é então atingido: nenhuma thread permanece disponível;
  • os trabalhos 5 e 6 tiveram de esperar que uma thread ficasse disponível depois do término dos trabalhos 0, 1 e 2. Vemos que eles reutilizaram as threads 7 e 4, que tinham executado os primeiros trabalhos;
  • No total, os trabalhos 5 e 6 levaram 6 segundos desde o momento em que foram solicitados: 3 segundos de espera e 3 segundos de execução.

Raramente é necessário alterar os limites do pool: seus valores padrão são adequados para a maioria das aplicações. Na verdade, [QueueUserWorkItem] raramente é usado diretamente: trabalhamos por meio de tarefas, que são descritas a seguir.

8.9. Tarefas e a Parallel Library

8.9.1. Task.Run

Desde o .NET 4, a classe [System.Threading.Tasks.Task] representa um trabalho (uma tarefa) executado de forma assíncrona. [Task.Run(action)] atribui um trabalho ao pool de threads, assim como [QueueUserWorkItem], mas retorna um objeto [Task] que permite acompanhar esse trabalho: verificar se terminou, esperar por ele, obter seu resultado ou a exceção que ele lançou. Uma tarefa que retorna um resultado do tipo T é do tipo [Task<T>]. O programa [threads-21.cs] é o seguinte:

// Task.Run: entregar uma tarefa ao pool de threads e obter seu resultado

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

// três tasks que retornam cada uma um resultado do 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})");
        // trabalho
        Thread.Sleep(500 * (number + 1));
        // o resultado da task
        return number * 10;
    });
}
// espera pelo fim das três tasks (bloqueante)
Task.WaitAll(tasks);
// os resultados
for (int i = 0; i < tasks.Length; i++)
{
    Console.WriteLine($"task {i}: status {tasks[i].Status}, result {tasks[i].Result}");
}

// uma task que lança uma exceção
Task failingTask = Task.Run(Fail);
try
{
    // a exceção da task é relançada por Wait, encapsulada em uma 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}");

// o trabalho da task que falha
static void Fail() => throw new InvalidOperationException("test....");

Comentários:

  • linhas 10–16: cada tarefa executa uma lambda que exibe a thread que a executa, dorme por 0,5, 1 ou 1,5 segundo e depois retorna um resultado do tipo [int]. [Task.Run] retorna, portanto, uma [Task<int>];
  • linha 20: a thread principal espera o término das três tarefas. Trata-se de uma espera bloqueante, como [Join];
  • linha 24: a propriedade [Status] indica o estado da tarefa; [RanToCompletion] significa que ela terminou normalmente;
  • linha 24: a propriedade [Result] é o resultado da tarefa. Se a tarefa não tivesse terminado, a leitura de [Result] bloquearia a thread até que ela terminasse;
  • linha 28: uma tarefa que executa o método [Fail], que lança uma exceção;
  • linha 32: a exceção lançada na tarefa não se perde: ela é armazenada no objeto [Task], e depois relançada na thread que espera pela tarefa. [Wait] a encapsula em uma [AggregateException] (uma tarefa pode agrupar várias delas), cuja propriedade [InnerException] é a exceção original;
  • linha 41: o método que lança a exceção. Poderíamos ter passado a lambda [() => throw new InvalidOperationException(...)] diretamente para [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
  • As tarefas são executadas em threads do pool (linha 3);
  • A tarefa 2 só começou depois que a tarefa 0 terminou, na thread que a tarefa 0 havia liberado: o pool tinha apenas 2 threads (o mínimo padrão nesta máquina) e não criou uma terceira a tempo;
  • os resultados são obtidos depois que as tarefas terminam;
  • a exceção da tarefa que falhou foi capturada pela thread principal, e o estado da tarefa é [Faulted].

Este exemplo também substitui o da classe [BackgroundWorker] do curso de 2008, que demonstrava como executar um trabalho em segundo plano, obter seu resultado ou sua exceção e cancelá-lo. [BackgroundWorker] foi concebido para interfaces gráficas Windows Forms; hoje ele foi substituído pelas tarefas, com o cancelamento tratado por [CancellationToken] e o acompanhamento do progresso pela interface [IProgress<T>], apresentados no próximo capítulo juntamente com [async] / [await], que permitem esperar por uma tarefa sem bloquear uma thread.

8.9.2. Parallel.For e Parallel.ForEach

A classe [System.Threading.Tasks.Parallel] (.NET 4) distribui automaticamente as iterações de um laço entre várias threads do pool:

  • [Parallel.For(start, end, i => ...)] executa o corpo do laço para i variando de [start] a [end] - 1;
  • [Parallel.ForEach(collection, element => ...)] executa o corpo do laço para cada elemento da coleção;
  • um parâmetro [ParallelOptions] permite limitar o número de iterações executadas simultaneamente (propriedade [MaxDegreeOfParallelism]);
  • ambos os métodos só devolvem o controle quando todas as iterações terminam. A thread que os chama participa ela mesma do trabalho.

Esses laços só são adequados se as iterações forem independentes: sua ordem de execução é indefinida e, se elas atualizam dados compartilhados, esses dados precisam ser protegidos. O programa [threads-22.cs] é o seguinte:

// a biblioteca paralela: Parallel.For e Parallel.ForEach

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

// 1 - contar os números primos menores que N
const int N = 5_000_000;
// versão sequencial
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");

// versão paralela nº 1: as iterações são distribuídas entre várias threads
stopwatch.Restart();
int nbParallel1 = 0;
Parallel.For(2, N, i =>
{
    if (IsPrime(i))
    {
        // o contador é compartilhado: incremento atômico
        Interlocked.Increment(ref nbParallel1);
    }
});
Console.WriteLine($"Parallel.For no. 1: {nbParallel1:N0} prime numbers in {stopwatch.ElapsedMilliseconds} ms");

// versão paralela nº 2: cada thread conta em uma variável local,
// que é somada ao total compartilhado apenas uma vez, no fim
stopwatch.Restart();
int nbParallel2 = 0;
// as threads que trabalharam e o número de números primos encontrados por cada uma
var threads = new ConcurrentDictionary<int, int>();
Parallel.For(2, N,
    // inicialização do contador local
    () => 0,
    // o corpo do laço retorna o novo valor do contador local
    (i, state, local) => IsPrime(i) ? local + 1 : local,
    // fim do trabalho de uma thread: somamos seu contador local ao 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 - processar uma coleção com no máximo 2 processamentos 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}");
    // processamento simulado
    Thread.Sleep(500);
});
Console.WriteLine("Parallel.ForEach finished");

// teste de primalidade (deliberadamente simples)
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;
}

Comentários:

  • linhas 7–18: contamos os números primos menores que 5.000.000 usando um laço [for] comum. A função [IsPrime] (linhas 68–81) testa os divisores até a raiz quadrada do número: é um processo demorado, e as iterações são independentes;
  • linhas 22–31: o mesmo laço com [Parallel.For]. O contador [nbParallel1] é compartilhado por todas as threads: ele é incrementado por [Interlocked.Increment] (uma variável local capturada por uma lambda pode ser passada por referência);
  • linhas 36–50: uma versão sobrecarregada de [Parallel.For] permite trabalhar com uma variável local: [Parallel.For] divide o laço em tarefas, cada uma executada por uma única thread, e cada tarefa tem seu próprio contador. A primeira lambda (41) inicializa o contador de uma tarefa; a segunda (43) é o corpo do laço, que recebe o contador e retorna seu novo valor; a terceira (45) é executada uma vez por tarefa, ao final de seu trabalho: ela soma o contador da tarefa ao total compartilhado. Isso reduz significativamente o número de operações atômicas;
  • linha 48: para cada thread que participou, registramos o número de números primos que ela encontrou;
  • linhas 57–65: [Parallel.ForEach] processa uma coleção de nomes de arquivos (o processamento é simulado por uma pausa de meio segundo), com no máximo 2 processamentos 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
  • Os três laços encontram o mesmo número de números primos;
  • várias threads participaram do laço paralelo, inclusive a thread principal (ID 1);
  • o processamento de [Parallel.ForEach] ocorre em pares, com meio segundo de intervalo, e em uma ordem que não corresponde à da lista;
  • O ganho de tempo nesta execução é decepcionante: há apenas 2 processadores, que as threads do nosso programa estavam dividindo com outros programas muito ativos no momento da captura. Em uma máquina pouco carregada com n processadores, um laço paralelo como este pode ser quase n vezes mais rápido que o laço sequencial. É sempre preciso medir antes de tirar conclusões: a paralelização tem um custo (distribuição do trabalho, sincronização) que só compensa se cada iteração envolver computação suficiente.

8.10. Dados locais a uma thread

8.10.1. O princípio

Considere uma aplicação de três camadas:

Image

Suponha que a aplicação seja multiusuário, como uma aplicação web. Cada requisição de usuário é tratada por uma thread. O ciclo de vida da thread é o seguinte:

  • a thread é criada ou obtida do pool de threads para atender à requisição de um usuário;
  • se essa requisição precisa de dados, a thread executa um método da camada [ui], que chama um método da camada [business], que por sua vez chama um método da camada [dao];
  • a thread devolve a resposta ao usuário. Em seguida, ela termina ou é devolvida ao pool de threads.

Durante a segunda etapa, pode ser útil que a thread tenha seus próprios dados, ou seja, dados não compartilhados com outras threads. Esses dados podem, por exemplo, pertencer ao usuário específico que a thread está atendendo e ser usados nas diversas camadas [ui, business, dao] sem serem passados como parâmetro a cada método.

O curso de 2008 usava para isso os métodos [Thread.SetData] e [Thread.GetData] , que gerenciam uma espécie de dicionário privado da thread. Eles ainda existem, mas raramente são usados; preferem-se duas ferramentas mais simples e mais eficientes:

  • o atributo [[ThreadStatic]] aplicado a um campo estático: cada thread tem sua própria instância do campo;
  • a classe [ThreadLocal<T>]: um objeto cuja propriedade [Value] tem um valor diferente para cada thread. Uma função passada ao construtor fornece o valor inicial de cada thread.

O programa [threads-23.cs] compara um campo estático comum com essas duas ferramentas:

// dados locais a uma thread: [ThreadStatic] e ThreadLocal<T>

Thread.CurrentThread.Name = "Main";
// a thread principal escreve seus próprios valores
Context.Shared = 100;
Context.PerThread = 100;
Context.User.Value = "admin";

// três threads escrevem e depois releem os três dados
var threads = new Thread[3];
for (int i = 0; i < threads.Length; i++)
{
    int number = i;
    threads[i] = new Thread(() =>
    {
        // escrita
        Context.Shared = number;
        Context.PerThread = number;
        // a thread T2 não define um usuário: ela receberá o valor padrão
        if (number != 2)
        {
            Context.User.Value = $"user{number}";
        }
        // deixamos as outras threads escreverem por sua vez
        Thread.Sleep(200);
        // releitura
        Display();
    })
    { Name = $"T{i}" };
    threads[i].Start();
}
foreach (Thread thread in threads)
{
    thread.Join();
}
// releitura pela thread principal
Display();

// exibe os dados vistos pela thread atual
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}");
}

// os dados do programa
static class Context
{
    // um campo estático comum: uma única cópia, compartilhada por todas as threads
    public static int Shared;
    // uma cópia por thread
    [ThreadStatic]
    public static int PerThread;
    // armadilha: o inicializador só é executado para a primeira thread que usa a classe
    [ThreadStatic]
    public static int WithInitializer = 5;
    // uma cópia por thread, inicializada para cada thread pela factory passada ao construtor
    public static readonly ThreadLocal<string> User = new(() => $"anonymous (thread {Thread.CurrentThread.Name})");
}

Comentários:

  • linha 49: um campo estático comum. Existe apenas uma instância dele, compartilhada por todas as threads;
  • linhas 51–52: o atributo [[ThreadStatic]] dá a cada thread uma instância do campo;
  • linhas 54–55: uma armadilha clássica. O inicializador [= 5] é executado pelo construtor estático da classe, uma única vez, na primeira thread que usa a classe. Para as outras threads, o campo tem o valor padrão de seu tipo, que neste caso é 0;
  • linha 57: um objeto [ThreadLocal<string>]. A lambda passada ao construtor é executada na primeira vez que uma thread lê [Value] sem ter escrito nele; ela fornece o valor inicial para essa thread;
  • linhas 5–7: a thread principal escreve seus próprios valores;
  • linhas 17–22: cada thread escreve seus próprios valores, exceto a thread T2, que não define um usuário;
  • linha 25: cada thread espera que as outras escrevam antes de ler os valores novamente.

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
  • o campo comum [Shared] tem o mesmo valor para todas as threads: o último valor escrito (nesta execução, o da thread T2);
  • o campo [PerThread] manteve, em cada thread, o valor que essa thread nele escreveu;
  • o campo [WithInitializer] vale 5 para a thread principal e 0 para as demais;
  • a propriedade [User.Value] tem o valor escrito por cada thread; a thread T2, que não havia escrito nela, recebeu o valor inicial fornecido pela lambda do construtor.

Os dados locais a uma thread têm uma limitação: seu escopo é a thread, não o processo. Com a programação assíncrona, tratada no próximo capítulo, um mesmo fluxo de execução pode começar em uma thread e continuar em outra depois de uma espera. Nesse caso, usamos a classe [AsyncLocal<T>], cujo valor persiste entre as threads.

8.10.2. Aplicação: uma transação compartilhada entre camadas

Considere a seguinte aplicação de três camadas, na qual a camada [dao] gerencia uma tabela de artigos:

Image

Suponha que a interface da camada [dao] seja inicialmente a seguinte:

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

Mais tarde, surge a necessidade de inserir um array de artigos dentro de uma transação, porque o sistema deve operar no regime de tudo ou nada: ou todos os artigos são inseridos, ou nenhum. Um método chamado [InsertArticles(Article[] articles)] pode ser adicionado à interface. Depois, para outra aplicação, surge a necessidade de excluir uma lista de artigos, também dentro de uma transação… Para atender a diferentes necessidades de negócio, a camada [dao] vai crescer. Podemos adotar outra abordagem:

  • incluir na camada [dao] apenas as operações básicas (inserir, atualizar, excluir, ler um artigo);
  • mover para a camada [business] as operações que atualizam simultaneamente vários artigos. Essas operações usam as operações básicas da camada [dao].

A vantagem dessa solução é que a mesma camada [dao] pode ser usada, sem modificação, com diferentes camadas [business]. Ela introduz uma dificuldade na gestão da transação que agrupa as atualizações a serem executadas de forma atômica:

  • a transação deve ser iniciada pela camada [business] antes de ela chamar os métodos da camada [dao];
  • os métodos da camada [dao] devem saber da existência da transação para participar dela;
  • a transação deve ser concluída (confirmada ou revertida) pela camada [business].

Para que os métodos da camada [dao] tomem conhecimento de qualquer transação em andamento, a transação poderia ser adicionada como parâmetro a cada método da camada [dao]. Esse parâmetro apareceria então na assinatura dos métodos da interface, o que vincularia a interface a uma fonte de dados específica. Os dados locais à thread oferecem uma solução mais elegante: a camada [business] coloca a transação nos dados locais da thread, e é ali que a camada [dao] a recupera. As assinaturas dos métodos da camada [dao] não precisam ser alteradas. Várias threads (vários usuários) podem trabalhar simultaneamente: cada uma tem sua própria transação.

O curso de 2008 usava um banco de dados SQL Server Compact, um produto que foi descontinuado. Os bancos de dados serão tratados nos capítulos sobre ADO.NET e Entity Framework Core. Para manter o foco nas threads, usaremos aqui uma tabela em memória e uma transação simulada. O programa [threads-24.cs] reúne todas as camadas em um único arquivo. As entidades são as seguintes:

// um artigo
record Article(int Id, string Name, decimal Price, int CurrentStock, int MinimumStock);

// uma transação simulada: ela registra como desfazer cada atualização
class Transaction
{
    private static int counter;
    private readonly Stack<Action> undos = new();
    public int Number { get; } = Interlocked.Increment(ref counter);

    // registra a operação que desfaz uma atualização
    public void Log(Action undo) => undos.Push(undo);
    // confirma a transação: as atualizações são mantidas
    public void Commit() => undos.Clear();
    // reverte a transação: as atualizações são desfeitas, da última à primeira
    public void Rollback()
    {
        while (undos.TryPop(out Action? undo))
        {
            undo();
        }
    }
}

// os dados locais da thread compartilhados pelas camadas
static class ThreadContext
{
    // a transação atual da thread (null se não houver nenhuma)
    public static readonly ThreadLocal<Transaction?> Transaction = new();
}
  • linha 60: um artigo é um [record] cujo identificador [Id] é definido pela camada [dao];
  • linhas 63–78: uma transação simulada. Cada atualização feita dentro da transação registra a operação necessária para desfazê-la (método [Log]); [Commit] confirma a transação ignorando essas operações; [Rollback] a reverte executando as operações de desfazer, da última para a primeira (daí a pilha [Stack<Action>]). Um banco de dados real opera de maneira semelhante, usando um log de transações;
  • linha 67: cada transação recebe um número único. Como transações podem ser criadas por várias threads simultaneamente, o contador é incrementado de forma atômica;
  • linhas 84–87: os dados locais à thread compartilhados pelas camadas: a transação atual da thread, ou [null] se não houver nenhuma.

A camada [dao] é a seguinte:

// a camada [dao]: uma tabela de artigos em memória com restrição de unicidade no nome
interface IDao
{
    int InsertArticle(Article article);
    List<Article> GetAllArticles();
    void DeleteAllArticles();
}

class Dao : IDao
{
    // a tabela, compartilhada por todas as threads, e seu lock
    private readonly List<Article> table = [];
    private readonly Lock padlock = new();
    private int nextId = 1;

    public int InsertArticle(Article article)
    {
        // há uma transação em andamento na thread atual?
        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 uma transação, registramos como desfazer a inserção
            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();
        }
    }
}
  • linha 101: a tabela de artigos, compartilhada por todas as threads. O acesso a ela é protegido pelo lock da linha 102;
  • linha 108: o método [InsertArticle] recupera a eventual transação que a camada [business] colocou nos dados locais da thread atual;
  • linhas 111–113: a tabela tem uma restrição de unicidade sobre os nomes dos artigos: inserir um artigo com um nome que já existe lança uma exceção;
  • linha 115: o artigo inserido é uma cópia do artigo recebido, com um identificador atribuído pela camada [dao]. A expressão [with] cria uma cópia de um [record] modificando certas propriedades;
  • linhas 118–122: se uma transação estiver em andamento, a camada [dao] participa dela registrando como desfazer a inserção. O operador [?.] chama [Log] somente se [transaction] não for [null];
  • linha 125: uma mensagem de rastreamento exibe a thread, o artigo inserido e a transação, se houver;
  • linhas 131–135: a lista de artigos retornada é uma cópia da tabela (expressão de coleção [.. table]), para que o chamador não a percorra enquanto outra thread a modifica.

A camada [business] é a seguinte:

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

class Business(IDao dao) : IBusiness
{
    // inserção de um array de artigos: tudo ou nada
    public void InsertArticlesInTransaction(Article[] articles)
    {
        // início da transação, armazenada nos dados locais da thread
        var transaction = new Transaction();
        ThreadContext.Transaction.Value = transaction;
        try
        {
            foreach (Article article in articles)
            {
                // a camada [dao] encontrará a transação na thread
                dao.InsertArticle(article);
                // processamento simulado, que dá tempo para outras threads entrarem em ação
                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
        {
            // a thread não tem mais transação em andamento
            ThreadContext.Transaction.Value = null;
        }
    }

    // inserção de um array de artigos sem transação
    public void InsertArticlesOutOfTransaction(Article[] articles)
    {
        foreach (Article article in articles)
        {
            dao.InsertArticle(article);
        }
    }

    public List<Article> GetAllArticles() => dao.GetAllArticles();
    public void DeleteAllArticles() => dao.DeleteAllArticles();
}
  • linha 157: a camada [dao] é injetada pelo construtor primário;
  • linhas 163–164: o método [InsertArticlesInTransaction] inicia uma transação e a grava nos dados locais da thread;
  • linha 170: o método de inserção da camada [dao] é chamado para cada artigo, sem que a transação lhe seja passada;
  • linha 172: uma pausa simula o processamento, para dar tempo a outra thread de intervir durante a transação (terceira parte do programa de teste);
  • linha 174: se o programa chega a este ponto, nenhuma exceção ocorreu: a transação é confirmada;
  • linhas 177–181: se ocorre uma exceção, a transação é revertida e a exceção é relançada ao chamador;
  • linha 186: em qualquer caso, a thread não tem mais uma transação ativa. Isso é importante se a thread for reutilizada (thread do pool);
  • linha 191: a mesma inserção, sem transação.

O programa de teste é o seguinte:

// dados locais a uma thread: a camada [business] coloca a transação ali, a camada [dao] a encontra ali

// as camadas da aplicação
IDao dao = new Dao();
IBusiness business = new Business(dao);
Thread.CurrentThread.Name = "Main";

// dois artigos com o mesmo nome: o segundo viola a restrição de unicidade no nome
Article[] articles = [new(0, "article", 100, 10, 1), new(0, "article", 100, 10, 1)];

// 1 - inserção fora de uma transação
Console.WriteLine("Inserting the articles outside a transaction...");
Execute(() => business.InsertArticlesOutOfTransaction(articles));
DisplayArticles(business);

// 2 - inserção dentro de uma transação
business.DeleteAllArticles();
Console.WriteLine("Inserting the articles inside a transaction...");
Execute(() => business.InsertArticlesInTransaction(articles));
DisplayArticles(business);

// 3 - duas threads simultâneas: a transação da thread A não é vista pela thread 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);

// executa uma ação, exibindo a possível exceção
static void Execute(Action action)
{
    try
    {
        action();
    }
    catch (Exception e)
    {
        Console.WriteLine($"[{Thread.CurrentThread.Name}] {e.GetType().Name} : {e.Message}");
    }
}

// exibe a lista de artigos
static void DisplayArticles(IBusiness business)
{
    Console.WriteLine("List of articles:");
    foreach (Article article in business.GetAllArticles())
    {
        Console.WriteLine($"  {article}");
    }
}
  • linha 9: criamos um array de dois artigos com o mesmo nome. A inserção do segundo artigo será rejeitada. Se a inserção for feita fora de uma transação, o primeiro artigo é inserido e permanece na tabela. Se for feita dentro de uma transação, o primeiro artigo é inserido e depois removido quando a transação é revertida;
  • linhas 11–14: inserimos o array fora de uma transação e depois exibimos a tabela;
  • linhas 16–20: o mesmo processo dentro de uma transação;
  • linhas 22–34: duas threads trabalham simultaneamente. A thread A insere três artigos dentro de uma transação (o terceiro viola a restrição de unicidade); enquanto isso, a thread B insere um artigo fora de uma transação;
  • linhas 37–45: a função [Execute] executa uma ação e exibe a eventual exceção, precedida do nome da thread.

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 }
  • A inserção fora da transação deixou o primeiro registro na tabela (linha 6);
  • a inserção feita dentro de uma transação não deixou nenhum registro na tabela: o registro com ID 2 foi removido pela reversão;
  • na terceira parte, a thread B inseriu a tela enquanto a transação 2 da thread A estava em andamento: ela o fez fora da transação, já que a transação é uma variável local da thread A. A reversão da transação 2 removeu o teclado e o mouse inseridos por A, mas não a tela inserida por B.

8.10.3. Conclusão

O exemplo anterior demonstrou a utilidade dos dados locais à thread para o gerenciamento de transações. Ele não deve ser replicado como está. O .NET fornece esse mecanismo pronto com a classe [System.Transactions.TransactionScope]: uma transação “ambiente”, acessível por [Transaction.Current], na qual as conexões de banco de dados participam automaticamente. Frameworks como o Entity Framework Core também gerenciam transações sem que o código da camada [dao] precise cuidar delas. E nas aplicações web de hoje, que são assíncronas, essa informação de contexto é transportada por [AsyncLocal<T>] e não por dados locais à thread.

8.11. Leituras complementares

A sincronização de threads é um campo desafiador. Este capítulo apresentou as principais ferramentas; para saber mais:

  • a documentação da Microsoft, capítulo “Threading in .NET”: Managed threading, particularmente a página “Overview of synchronization primitives”;
  • a documentação da Microsoft, capítulo “Parallel Programming”: Parallel Programming in .NET, que trata da biblioteca [Parallel], das tarefas e das coleções concorrentes;
  • o capítulo “Threading” do livro de Joseph Albahari, [C# in a Nutshell], cuja edição para C# 3.0 o curso de 2008 já recomendava. Uma versão mais antiga, mas ainda instrutiva, desse capítulo está disponível on-line: Threading in C#.

No código moderno, raramente se manipulam diretamente objetos [Thread]. Preferem-se as tarefas ([Task]), que são executadas no pool de threads, e sobretudo a programação assíncrona com as palavras-chave [async] e [await], que permite esperar por uma operação demorada (rede, banco de dados ou acesso a arquivos) sem bloquear uma thread. Esse é o assunto do próximo capítulo. Ainda assim, os conceitos tratados neste capítulo continuam essenciais: as tarefas são executadas em threads, e os dados que elas compartilham devem ser protegidos com as mesmas ferramentas ([lock], [Interlocked], coleções concorrentes).