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

CKTIS / Java

Thread: iniciar, aguardar a conclusão e interromper

Cria threads de plataforma a partir de tarefas Runnable, inicia-as uma só vez, lê os resultados após join() e preserva o estado de interrupção durante um cancelamento cooperativo.

Versão: Java SE 21

Sintaxe

new Thread(task);             // task: Runnable
new Thread(task, name);       // name: String
worker.start();               // void
worker.join();                // void; throws InterruptedException
worker.join(millis);          // long; same return and checked exception
worker.join(millis, nanos);   // long, int; same return and checked exception
worker.join(duration);        // java.time.Duration; boolean; throws InterruptedException
Thread.currentThread();       // static; returns Thread
worker.getName();             // returns String
worker.interrupt();           // request interruption of worker
Thread.currentThread().interrupt(); // set the calling thread's interrupt status

Em Java SE 21, ambos os construtores de java.lang.Thread criam uma thread de plataforma ainda não iniciada, não uma thread virtual. Thread(Runnable) gera um nome; Thread(Runnable,String) usa o nome fornecido. O método estático Thread.currentThread() devolve a thread que executa a chamada. O método de instância getName() devolve o seu nome, uma etiqueta e não um identificador único.

worker.start() agenda a execução da tarefa na nova thread. Chamar diretamente worker.run() executa a tarefa na thread que fez a chamada. Uma segunda chamada a start() lança IllegalThreadStateException, mesmo depois de a thread terminar. A relação happens-before torna as ações anteriores a start() visíveis à thread iniciada. A ordem de arranque não determina a ordem de execução.

worker.join() faz a thread chamadora aguardar até que a thread iniciada termine; retorna de imediato se a thread ainda não tiver sido iniciada. Quando join() retorna normalmente para uma thread iniciada, as escritas dessa thread ficam visíveis para quem fez a chamada. Aguarda por todos os produtores antes de ler os resultados: isso não resolve corridas de dados entre produtores nem demonstra o êxito das tarefas. join(long) e join(long,int) podem retornar quando o prazo termina; se todos os argumentos forem zero, não há prazo. join(Duration) indica se a thread terminou e lança IllegalThreadStateException se ainda não tiver sido iniciada.

worker.interrupt() sinaliza uma interrupção à thread de trabalho, mas não a força a parar. Quando join() ou await() lança InterruptedException, o estado de interrupção da thread chamadora é limpo. Propaga a exceção se puderes; caso contrário, liberta os recursos, repõe o estado com Thread.currentThread().interrupt() e termina o percurso de cancelamento sem indicar sucesso. isInterrupted() lê o estado sem o limpar; o método estático Thread.interrupted() lê e limpa o estado da thread atual. Não dependas da interrupção de uma thread que não esteja viva. Em Java SE 21, um gestor de segurança pode impedir a interrupção de outra thread.

Exemplos

import java.util.concurrent.CountDownLatch;

public class ThreadMethodsDemo {
    public static void main(String[] args) throws InterruptedException {
        var gate = new CountDownLatch(1);
        var observations = new String[2];

        Thread compute = new Thread(() -> observations[0] = "sum=" + (20 + 22));
        Thread cancellable = new Thread(() -> {
            Thread self = Thread.currentThread();
            try {
                gate.await();
            } catch (InterruptedException e) {
                self.interrupt();
                observations[1] = self.getName() + ": cancelled; interrupted="
                        + self.isInterrupted();
                return;
            }
        }, "cancellable");

        compute.start();
        cancellable.start();
        cancellable.interrupt();
        compute.join();
        cancellable.join();

        System.out.println(observations[0]);
        System.out.println(observations[1]);
    }
}

Resultado

sum=42
cancellable: cancelled; interrupted=true

A primeira thread guarda uma soma; a thread com nome regista o cancelamento. O mecanismo de contagem permanece fechado: `await()` reage à interrupção antes ou durante a espera. Só `main` escreve na consola, após ambos os `join()`, pelo que a ordem das linhas não depende do escalonamento.

Lições relacionadas

  • Java · Lição 25 · Avançado · Versão: 2
  • Java · Lição 28 · Avançado · Versão: 2
  • Java · Lição 30 · Avançado · Versão: 2
  • Java · Lição 33 · Avançado · Versão: 2
  • Java · Lição 34 · Avançado · Versão: 2
  • Java · Lição 35 · Avançado · Versão: 2
  • Java · Lição 36 · Avançado · Versão: 2
  • Java · Lição 37 · Avançado · Versão: 2
  • Java · Lição 38 · Avançado · Versão: 2

Fontes