Obtenir ID de thread en Java

En Java, appelez Thread.getId() sur un objet Thread pour lire l’identifiant de ce thread. Lorsqu’une tâche s’exécute dans un executor, Thread.currentThread().getId() renvoie l’identifiant du thread de travail qui l’exécute. Les exemples ci-dessous montrent ces deux cas ; aucune de ces valeurs ne désigne un pool de threads ni un nom de thread. Utilisez la première méthode si vous disposez déjà d’une référence à un objet Thread, et la seconde depuis le code d’une tâche pour identifier le thread qui l’exécute.

Obtenir l’identifiant d’un thread Java avec Thread.getId()

Créez un objet Thread, puis appelez sa méthode getId() pour récupérer l’identifiant de cet objet sous forme de long. Le premier exemple crée deux objets thread et lit leurs identifiants. Il ne démarre pas les threads : ce n’est pas nécessaire pour lire les identifiants de ces objets. Le runtime attribue les valeurs des identifiants ; elles peuvent varier d’une exécution ou d’un environnement à l’autre. Utilisez donc la valeur renvoyée à l’exécution au lieu de vous fier aux nombres de l’exemple. Cette méthode est utile lorsque le code possède une référence à un Thread particulier et doit le distinguer d’un autre objet de ce type.

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

Exemple de sortie pour une exécution :
Les libellés du bloc de sortie restent en anglais, car cet exemple est reproduit à l’identique.

Thread 1 ID: 12
Thread 2 ID: 13

Les identifiants numériques ci-dessus sont donnés à titre d’illustration et dépendent du runtime. Comme les threads ne sont pas démarrés, le programme affiche les deux identifiants d’objet dans l’ordre des instructions d’affichage ; les nombres de l’exemple ne sont garantis ni lors d’une autre exécution ni dans un autre environnement.

Obtenir l’identifiant du thread de travail courant dans un pool avec Thread.currentThread().getId()

Une tâche soumise à un executor s’exécute sur l’un de ses threads de travail. Appelez Thread.currentThread().getId() depuis la tâche pour obtenir l’identifiant du thread qui l’exécute à cet instant. Il s’agit de l’identifiant d’un thread de travail, et non de celui de l’executor ou du pool. Un pool fixe réutilise ses threads : plusieurs tâches peuvent donc renvoyer le même identifiant de thread de travail. L’ordonnancement détermine quel thread prend en charge chaque tâche ; l’ordre des tâches et les identifiants numériques peuvent varier. Cette distinction est utile pour diagnostiquer quel thread a effectué une opération : le nombre renvoyé décrit le thread en cours d’exécution à cet instant, pas l’executor qui a planifié la tâche.

L’exemple soumet cinq tâches, affiche le numéro de chaque tâche et l’identifiant de son thread de travail, puis arrête l’executor. shutdown() empêche l’acceptation de nouvelles tâches tout en permettant aux tâches déjà soumises de se terminer. awaitTermination attend leur achèvement pendant une minute au maximum, sans attente active. Si le travail dure plus longtemps, le programme indique que le délai d’attente a expiré ; la demande d’arrêt ayant déjà été envoyée, les tâches en attente peuvent continuer. En production, choisissez un délai adapté au travail de l’application et définissez la réponse à apporter si les tâches ne se terminent pas à temps. Pour choisir les détails de l’API correspondant à une version précise de Java, consultez la documentation de cette version ; aucune version cible n’est spécifiée ici.

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");
  }
}

Exemple de sortie pour une exécution ; l’ordre des tâches et les identifiants numériques dépendent du runtime :
Les libellés du bloc de sortie restent en anglais, car cet exemple est reproduit à l’identique.

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

Placez l’appel dans la tâche si vous voulez identifier le thread qui l’exécute. Appelé ailleurs, il renvoie l’identifiant du thread qui exécute cet autre code. Comme un pool peut réutiliser ses threads et planifier les tâches différemment, servez-vous de la sortie pour comprendre une exécution donnée, et non comme d’une correspondance fixe entre les numéros de tâche et les identifiants des threads de travail.