Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C#

Thread.Start/Join e Monitor.Wait/PulseAll: threads e condições

Inicia uma thread real, usa um monitor para aguardar uma alteração do estado partilhado e aguarda separadamente o fim da thread. Uma notificação não prova que a condição esteja satisfeita.

Versão: C# 12 and .NET 8; later runtimes may add compatible features

Sintaxe

using System.Threading;

// Thread — instance methods
void Start();
void Start(object? parameter);
void Join();
bool Join(int millisecondsTimeout);
bool Join(TimeSpan timeout);

// Monitor — static methods
static bool Wait(object obj);
static bool Wait(object obj, int millisecondsTimeout);
static bool Wait(object obj, TimeSpan timeout);
static bool Wait(object obj, int millisecondsTimeout, bool exitContext);
static bool Wait(object obj, TimeSpan timeout, bool exitContext);
static void PulseAll(object obj);

// Waiter: check the condition while holding the monitor.
lock (gate) { while (!ready) Monitor.Wait(gate); }

// Publisher: update the condition before notifying waiters.
lock (gate) { ready = true; Monitor.PulseAll(gate); }

Em C# 12 e .NET 8, os métodos de instância de Thread, no espaço de nomes System.Threading, gerem o ciclo de vida de uma thread. Start() agenda a sua execução sem esperar que o delegado termine. Start(object?) passa um argumento a ParameterizedThreadStart; com ThreadStart, esta sobrecarga lança InvalidOperationException. Start() passa null a ParameterizedThreadStart. Iniciar a mesma thread duas vezes lança ThreadStateException, mesmo depois de a thread terminar.

Join() bloqueia a thread que o chama até que a thread de destino termine. As sobrecargas com int (milissegundos) ou TimeSpan devolvem true se a thread terminou, ou false se o tempo de espera expirou. Join não para a thread e lança ThreadStateException se esta ainda não tiver sido iniciada. Não chames Join() sem limite na própria thread nem enquanto deténs um bloqueio de que a thread de destino necessita: podes provocar um impasse.

Usa o mesmo objeto gate, dedicado a este fim e não exposto, para ler e escrever o estado partilhado. Com um object, lock (gate) usa Monitor.Enter e Monitor.Exit e liberta o bloqueio mesmo se houver uma exceção; TryEnter tenta adquirir o bloqueio, não aguardar uma condição. Os métodos estáticos Monitor.Wait(gate) e Monitor.PulseAll(gate) exigem que quem chama detenha esse bloqueio, caso contrário lançam SynchronizationLockException. Wait liberta temporariamente só esse bloqueio e volta a adquiri-lo antes de retornar, repondo o nível de reentrada. As sobrecargas com limite de tempo (int em milissegundos ou TimeSpan) devolvem um bool relativo ao tempo, não à condição. Voltar a adquirir o bloqueio pode demorar mais do que o limite indicado. As sobrecargas que aceitam exitContext estão disponíveis no .NET 8, mas o ambiente de execução ignora esse argumento.

Com o bloqueio adquirido, altera o estado antes de chamar PulseAll. O método move todas as threads à espera nesse monitor para a fila das threads prontas (Pulse move apenas uma), mas não liberta o bloqueio nem guarda um sinal para quem vier a esperar mais tarde. Testa a condição num while, não num if: outra thread pode alterar o estado antes de voltares a adquirir o bloqueio. Este protocolo é bloqueante, não é await; o exemplo destina-se a uma consola .NET 8, não a um navegador.

Exemplos

using System;
using System.Threading;

object gate = new();
bool ready = false;
int result = 0;

var worker = new Thread(() =>
{
    lock (gate)
    {
        result = 42;
        ready = true;
        Monitor.PulseAll(gate);
    }
});

int observed;
lock (gate)
{
    worker.Start();
    while (!ready)
    {
        Monitor.Wait(gate);
    }
    observed = result;
}

worker.Join();
Console.WriteLine($"Result: {observed}");
Console.WriteLine("Worker finished.");

Resultado

Result: 42
Worker finished.

A thread principal chama `Start()` enquanto detém o bloqueio de `gate`, pelo que a thread de trabalho não pode definir `ready` até `Wait` libertar o bloqueio. Depois de voltar a adquiri-lo, a thread principal lê `result`, sai de `lock` e só então chama `Join()`. As linhas esperadas são `Result: 42` e `Worker finished.`, por esta ordem.

Lições relacionadas

  • C# · Lição 17 · Avançado · Versão: 3

Fontes