Description

can you explain the java thread lifecycle ?

# Le cycle de vie d’un thread Java : tout ce que vous devez savoir

La concurrence est l’une des compétences les plus recherchées chez les développeurs Java.
Mais pour tirer le meilleur parti des threads, il faut d’abord comprendre où ils se trouvent : **quelles sont leurs étapes ?**
Dans cet article, on décortique le cycle de vie d’un thread Java, on passe en revue les six états qu’il peut occuper, et on vous montre comment les surveiller avec `Thread.getState()`.

> **Astuce** : Le tableau suivant vous donne un aperçu rapide de chaque état :

| État | Description | Exemple d’utilisation |
|——|————-|———————–|
| NEW | Le thread est créé mais pas encore démarré | `Thread t = new Thread(…);` |
| RUNNABLE | Le thread est prêt à s’exécuter | `t.start();` |
| BLOCKED | Le thread attend un verrou (moniteur) | `synchronized (obj) { … }` |
| WAITING | Le thread attend indéfiniment un signal | `wait()`, `join()` |
| TIMED_WAITING | Le thread attend pendant un délai limité | `sleep()`, `wait(timeout)` |
| TERMINATED | Le thread a terminé son exécution | Fin de la méthode `run()` |

—

## 1. Créer un thread : l’étape NEW

“`java
Runnable task = () -> System.out.println(“Hello world”);
Thread t = new Thread(task);
“`

À ce stade, `t.getState()` renvoie `Thread.State.NEW`.
Le thread n’a pas encore appelé `run()`. Vous pouvez encore modifier sa priorité, son nom, ou encore le thread pool qui l’exécutera.

> **Conseil** : N’appelez jamais `run()` directement ; cela exécuterait la tâche dans le thread appelant, pas dans un nouveau thread.

—

## 2. Démarrer le thread : RUNNABLE

“`java
t.start(); // passe l’objet dans l’état RUNNABLE
“`

`start()` crée un nouveau thread d’exécution et appelle automatiquement `run()`.
Dans ce moment, le thread est *prêt* à être planifié par le scheduler, mais il n’est pas garanti qu’il s’exécute immédiatement.
La JVM peut aussi décider d’exécuter `run()` dans le même thread que `start()` si le thread a déjà terminé — un détail à garder à l’esprit lors du debug.

—

## 3. Quand un thread se bloque : BLOCKED

Un thread passe à BLOCKED lorsqu’il tente d’acquérir un verrou déjà détenu par un autre thread.

“`java
public class Counter {
private int count = 0;

public synchronized void inc() {
count++; // le thread est bloqué si un autre thread est dans inc()
}
}
“`

En cas de concurrence, vous verrez l’état `BLOCKED` dans le tableau de bord de votre IDE ou dans une trace de `Thread.getState()`.

> **Astuce** : Utilisez des verrous explicites (`ReentrantLock`) ou des structures concurrentes (`ConcurrentHashMap`) pour réduire les blocages.

—

## 4. Attente sans limite : WAITING

Un thread entre en WAITING lorsqu’il appelle `Object.wait()` sans délai, ou `Thread.join()` sur un autre thread.

“`java
public synchronized void pause() throws InterruptedException {
wait(); // le thread est en WAITING jusqu’à ce qu’il soit notify()
}
“`

Le thread restera en attente jusqu’à ce qu’un autre thread invoque `notify()` ou `notifyAll()` sur le même objet, ou qu’une interruption se produise.

> **Astuce** : Dans un environnement multi-thread, veillez à toujours invoquer `notifyAll()` pour éviter les interblocages.

—

## 5. Attente limitée : TIMED_WAITING

Quand un thread attend avec un délai, son état devient TIMED_WAITING.

“`java
Thread.sleep(500); // le thread est en TIMED_WAITING pour 500 ms
“`

De même, `wait(1000)` ou `join(2000)` mettent le thread dans ce même état.
Si le délai expire, le thread revient à RUNNABLE.

—

## 6. Terminé : TERMINATED

Une fois que `run()` se termine (ou que le thread est interrompu avec `stop()` — méthode obsolète !), il passe à TERMINATED.
Aucun autre appel à `start()` ne sera permis pour ce thread.

—

## 7. Surveiller l’état avec `Thread.getState()`

“`java
System.out.println(“État actuel : ” + t.getState());
“`

Cette méthode est extrêmement utile lors du debugging.
Vous pouvez par exemple créer une boucle qui affiche l’état toutes les 200 ms pour voir comment votre thread évolue :

“`java
while (t.isAlive()) {
System.out.println(“Thread state : ” + t.getState());
Thread.sleep(200);
}
“`

—

## 8. Pourquoi est‑ce important ?

– **Gestion des ressources** : Un thread bloqué trop longtemps peut épuiser les verrous et ralentir l’application.
– **Débogage** : Connaître l’état d’un thread permet de repérer les interblocages ou les deadlocks.
– **Optimisation** : Savoir qu’un thread est en WAITING vous donne la possibilité d’utiliser des primitives plus efficaces (ex. `Condition`).

—

## 9. Bonnes pratiques

| Situation | Recommandation |
|———–|—————-|
| Créer un thread | Utiliser `ExecutorService` pour gérer la pool. |
| Verrouiller | Eviter les verrous imbriqués. |
| Attendre | Utiliser `Condition` ou `CountDownLatch` pour synchroniser proprement. |
| Terminer | Toujours libérer les ressources dans un bloc `finally`. |

—

## 10. Conclusion

Comprendre le cycle de vie d’un thread Java est la première étape pour écrire du code concurrent robuste.
Les six états (NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED) vous donnent une vue claire de ce qui se passe dans votre application, et `Thread.getState()` est votre meilleur allié pour surveiller ces changements en temps réel.

En maîtrisant ces concepts, vous pouvez diagnostiquer plus facilement les problèmes de performance, éviter les interblocages, et profiter pleinement de la puissance de la concurrence en Java.

> **Prochaine étape** : plongez dans les primitives de synchronisation avancées (`ReentrantLock`, `Condition`, `Semaphore`) pour aller plus loin dans l’art de la concurrence.

—

**Références**

– GeeksforGeeks – *Thread Lifecycle and States in Java*
– Baeldung – *Java Thread Lifecycle*
– JavaPoint – *Life cycle of a thread*
– Javadoc – `Thread.State`
– Stack Overflow – *What is the lifecycle of thread in Java?*

Bonne lecture et bon multithreading !