Exemples Java - Obtenir l'état du thread

Java 实例Exemples Java

Dans le cycle de vie d'un thread Java, la classe Thread possède un type d'énumération State qui définit plusieurs états de thread, à savoir :

  • Nouveau
  • Exécutable
  • Bloqué
  • En attente
  • En attente chronométrée
  • Terminé

Description de chaque état :

1. État initial - NEW

Déclaration :

public static final Thread.State NEW

L'implémentation de l'interface Runnable et l'extension de Thread peuvent produire une classe de thread. Lorsqu'une instance est créée avec new, le thread entre dans l'état initial.

2. RUNNABLE

Déclaration :

public static final Thread.State RUNNABLE

2.1. État prêt

L'état prêt signifie simplement que vous êtes qualifié pour être exécuté. Si l'ordonnanceur ne vous sélectionne pas, vous serez toujours dans l'état prêt.

L'appel de la méthode start() du thread place le thread dans l'état prêt.

Lorsque la méthode sleep() du thread courant se termine, que le join() d'un autre thread se termine, que l'attente d'une entrée utilisateur se termine, ou qu'un thread obtient le verrou de l'objet, ces threads entrent également dans l'état prêt.

Lorsque le thread courant a épuisé sa tranche de temps, ou que la méthode yield() est appelée sur le thread courant, le thread courant entre dans l'état prêt.

Après qu'un thread du pool de verrous obtient le verrou de l'objet, il entre dans l'état prêt.

2.2. État en cours d'exécution

L'état dans lequel se trouve un thread lorsque l'ordonnanceur de threads le sélectionne dans le pool des threads exécutables comme thread courant. C'est également la seule façon pour un thread d'entrer dans l'état d'exécution.

3. État bloqué - BLOCKED

Déclaration :

public static final Thread.State BLOCKED

L'état bloqué est l'état dans lequel un thread est bloqué lors de l'entrée dans une méthode ou un bloc de code modifié par le mot-clé synchronized (acquisition d'un verrou).

4. En attente - WAITING

Déclaration :

public static final Thread.State WAITING

Les threads dans cet état ne reçoivent pas de temps d'exécution CPU. Ils doivent attendre d'être explicitement réveillés, sinon ils seront dans un état d'attente indéfinie.

5. Attente temporisée - TIMED_WAITING

Déclaration :

public static final Thread.State TIMED_WAITING

Les threads dans cet état ne reçoivent pas de temps d'exécution CPU, mais ils n'ont pas besoin d'attendre indéfiniment pour être explicitement réveillés par d'autres threads ; après un certain temps, ils se réveilleront automatiquement.

6. État terminé - TERMINATED

Déclaration :

public static final Thread.State TERMINATED

Lorsque la méthode run() d'un thread se termine, ou que la méthode main() du thread principal se termine, nous le considérons comme terminé. L'objet thread peut être encore vivant, mais il n'est plus un thread d'exécution distinct. Une fois qu'un thread est terminé, il ne peut pas être ressuscité.

L'appel de la méthode start() sur un thread terminé lève une java.lang.IllegalThreadStateException.

L'exemple suivant montre comment obtenir l'état d'un thread :

Fichier Main.java

//Programme Java - Démonstration de l'état d'un thread class thread implements Runnable { public void run() { //thread2 - Attente temporisée try { Thread.sleep(1500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("État de thread1 lorsqu'il a appelé la méthode join() sur thread2 -"+ Test.thread1.getState()); try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } } } public class Test implements Runnable { public static Thread thread1; public static Test obj; public static void main(String[] args) { obj = new Test(); thread1 = new Thread(obj); //Création de thread1, il est maintenant dans l'état initial System.out.println("État de thread1 après sa création - " + thread1.getState()); thread1.start(); //thread1 - État prêt System.out.println("État de thread1 après appel de la méthode .start() sur celui-ci - " + thread1.getState()); } public void run() { thread myThread = new thread(); Thread thread2 = new Thread(myThread); //thread1 créé, il est maintenant dans l'état initial System.out.println("État de thread2 après sa création - "+ thread2.getState()); thread2.start(); //thread2 - État prêt System.out.println("État de thread2 après appel de la méthode .start() sur celui-ci - " + thread2.getState()); // mise de thread1 en état d'attente temporisée try { //déplacement - Attente temporisée Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("État de thread2 après appel de la méthode .sleep() sur celui-ci - "+ thread2.getState() ); try { //En attente de la terminaison de thread2 thread2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("État de thread2 lorsqu'il a terminé son exécution - " + thread2.getState()); } }

La sortie du code ci-dessus est :

State of thread1 after creating it - NEW
State of thread1 after calling .start() method on it - RUNNABLE
State of thread2 after creating it - NEW
State of thread2 after calling .start() method on it - RUNNABLE
State of thread2 after calling .sleep() method on it - TIMED_WAITING
State of thread1 while it called join() method on thread2 -WAITING
State of thread2 when it has finished it's execution - TERMINATED

Java 实例Exemples Java

Autres extensions