Obter Thread Id em Java

Em Java, chame Thread.getId() num objeto Thread para obter o identificador dessa thread. Enquanto uma tarefa é executada por um executor, Thread.currentThread().getId() identifica a thread trabalhadora que a está a executar. Os exemplos abaixo mostram ambos os casos; nenhum dos valores identifica um pool de threads ou o nome de uma thread. Use a primeira abordagem quando já tiver uma referência a Thread e a segunda, dentro do código de uma tarefa, quando precisar de identificar a thread trabalhadora que a executa.

Obter o ID de uma thread em Java com Thread.getId()

Crie um objeto Thread e chame o método getId() para obter o identificador desse objeto como um valor long. O primeiro exemplo cria dois objetos de thread e lê os respetivos IDs. As threads não são iniciadas; isso não é necessário para ler os identificadores destes objetos. Os valores são atribuídos pelo ambiente de execução e podem variar entre execuções ou ambientes. Por isso, use o valor devolvido durante a execução, em vez de depender dos números de exemplo. Esta abordagem é útil quando o código tem uma referência a uma Thread específica e precisa de a distinguir de outra.

public class GetThreadID {
  public static void main(String[] args) {
    Thread thread1 = new Thread();
    Thread thread2 = new Thread();

    System.out.println("Thread 1 ID: " + thread1.getId());
    System.out.println("Thread 2 ID: " + thread2.getId());
  }
}

Saída ilustrativa de uma execução:
A saída abaixo mostra os IDs dos dois objetos. O rótulo apresentado no bloco permanece em inglês, pois o bloco foi preservado sem alterações.

Thread 1 ID: 12
Thread 2 ID: 13

Os IDs numéricos acima são ilustrativos e dependem do ambiente de execução. Como as threads não são iniciadas, o programa apresenta os IDs dos dois objetos pela ordem das instruções de impressão. Os números do exemplo não são garantidos noutra execução ou ambiente.

Obter o ID da thread trabalhadora atual num pool de threads com Thread.currentThread().getId()

Uma tarefa submetida a um executor é executada por uma das suas threads trabalhadoras. Chame Thread.currentThread().getId() dentro da tarefa para obter o ID da thread que a está a executar. Esse é o ID de uma thread trabalhadora, não uma identidade do executor ou do pool. Um pool fixo reutiliza as suas threads, pelo que tarefas diferentes podem apresentar o mesmo ID. O escalonamento determina qual thread trata cada tarefa, e tanto a ordem das tarefas como os IDs numéricos podem variar. Esta distinção é útil para diagnosticar qual thread realizou uma unidade de trabalho: o número devolvido descreve a thread que a executa naquele momento, e não o executor que a agendou.

O exemplo submete cinco tarefas, apresenta o número de cada tarefa e o ID da thread que a executa e, em seguida, encerra o executor. shutdown() impede a aceitação de novas tarefas, permitindo que as já submetidas terminem. awaitTermination aguarda a conclusão durante, no máximo, um minuto, sem espera ativa. Se o trabalho demorar mais, o programa informa que o tempo de espera expirou; o pedido de encerramento já foi feito, pelo que as tarefas em fila podem continuar. Em código de produção, escolha um tempo limite adequado ao trabalho da aplicação e defina como reagir se as tarefas não terminarem a tempo. Se precisar de escolher detalhes da API para uma versão específica de Java, consulte a documentação dessa versão; aqui não foi especificada uma versão-alvo.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class GetThreadID {
  public static void main(String[] args) throws InterruptedException {
    ExecutorService executor = Executors.newFixedThreadPool(2);

    for (int i = 1; i <= 5; i++) {
      final int taskNumber = i;
      executor.execute(() -> {
        long workerId = Thread.currentThread().getId();
        System.out.println("Task " + taskNumber + " ran on worker ID " + workerId);
      });
    }

    executor.shutdown();
    boolean finished = executor.awaitTermination(1, TimeUnit.MINUTES);
    System.out.println(finished ? "All tasks finished" : "Wait timed out");
  }
}

Saída ilustrativa de uma execução; a ordem das tarefas e os IDs numéricos dependem do ambiente de execução:
A saída abaixo mostra os números das tarefas e os IDs das threads trabalhadoras. Os rótulos apresentados no bloco permanecem em inglês, pois o bloco foi preservado sem alterações.

Task 2 ran on worker ID 13
Task 3 ran on worker ID 13
Task 4 ran on worker ID 13
Task 5 ran on worker ID 13
Task 1 ran on worker ID 12
All tasks finished

Coloque a chamada dentro da tarefa quando quiser identificar a thread que a está a executar. Se a chamar noutro local, obterá a thread que executa esse outro código. Como um pool pode reutilizar threads e escalonar tarefas de formas diferentes, use a saída para compreender uma execução específica, não como uma correspondência fixa entre números de tarefas e IDs de threads trabalhadoras.