Etude approfondie de plusieurs états des threads Java et de leur impact sur l'exécution du programme

Étude approfondie de plusieurs états des threads Java et de leur impact sur l'exécution du programme

En Java, un thread est une unité d'exécution légère qui peut s'exécuter indépendamment dans un programme et effectuer des tâches spécifiques. L'état d'un thread décrit les différentes étapes de l'exécution d'un thread. Comprendre l'état d'un thread est très important pour écrire des programmes multithread et optimiser les performances du programme. Cet article examinera plusieurs états des threads Java et leur impact sur l'exécution du programme, et fournira des exemples de code spécifiques.

Les différents états des threads Java incluent : NEW (nouveau), RUNNABLE (exécutable), BLOCKED (bloqué), WAITING (en attente), TIMED_WAITING (en attente chronométrée) et TERMINATED (terminé).

1. Nouvel (NOUVEAU) état : Lorsqu'un nouveau thread est créé en créant une instance de la classe Thread, le thread est dans le nouvel état. Dans le nouvel état, le thread n’a pas encore commencé à exécuter du code. Voici un exemple de code pour créer un nouveau thread :

Thread thread = new Thread(() -> {
    System.out.println("Hello, World!");
});

2. État exécutable (RUNNABLE) : lorsque le thread appelle la méthode start(), le thread entre dans l'état exécutable. Dans cet état, le thread attendra que le CPU alloue une tranche de temps afin d'exécuter le code dans la méthode run(). S'il existe plusieurs threads dans un état exécutable, le système d'exploitation allouera des tranches de temps à ces threads conformément à la politique de planification. Voici un exemple de code :

Thread thread = new Thread(() -> {
    System.out.println("Hello, World!");
});
thread.start();

3. État bloqué (BLOQUÉ) : lorsque le thread ne peut pas continuer à s'exécuter pour une raison quelconque, le thread entre dans l'état bloqué. Les raisons courantes incluent l'attente des verrous, l'attente des entrées et des sorties (E/S), etc. Dans l'état de blocage, le thread suspend l'exécution jusqu'à ce qu'une certaine condition soit remplie avant de pouvoir poursuivre l'exécution. Voici un exemple de code qui utilise le mot-clé synchronisé pour réaliser la synchronisation des threads :

public class MyRunnable implements Runnable {
    private Object lock = new Object();
    
    public void run() {
        synchronized(lock) {
            System.out.println("In synchronized block");
            // 一些代码
        }
    }
  
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
  
        thread1.start();
        thread2.start();
    }
}

Dans le code ci-dessus, deux threads tentent d'entrer dans le bloc synchronisé en même temps, car le verrou est partagé, le deuxième thread entrera dans le blocage état jusqu'à ce que le premier thread termine l'exécution et libère le verrou.

4. État d'attente (WAITING) : le thread entrera dans l'état d'attente dans les circonstances suivantes : la méthode wait() est appelée, la méthode join() est appelée ou la méthode park() de LockSupport est appelée. Dans l'état d'attente, le thread n'exécutera activement aucun code jusqu'à ce que d'autres threads le réveillent ou que le temps d'attente expire. Voici un exemple de code utilisant la méthode wait() :

public class MyThread extends Thread {
    public void run() {
        synchronized(this) {
            System.out.println("Waiting for next thread...");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread resumed.");
        }
    }
  
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
  
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized(thread) {
            thread.notify();
        }
    }
}

Dans le code ci-dessus, une fois que le thread est entré dans l'état d'attente, le thread principal réveille le thread via la méthode notify().

5. État d'attente temporisée (TIMED_WAITING) : le thread entrera dans l'état d'attente temporisé dans les circonstances suivantes : la méthode sleep() est appelée, la méthode join() avec un paramètre timeout est appelée et la méthode wait() avec un Le paramètre timeout est appelé méthode, appelant la méthode parkNanos() ou la méthode parkUntil() de LockSupport. Dans l'état d'attente planifié, le thread n'exécutera activement aucun code et sera réveillé une fois le temps d'attente atteint. Voici un exemple de code utilisant la méthode sleep() :

public class MyThread extends Thread {
    public void run() {
        try {
            System.out.println("Thread sleeping...");
            Thread.sleep(2000);
            System.out.println("Thread woke up.");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
  
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

Dans le code ci-dessus, le thread entre dans l'état d'attente planifié en appelant la méthode sleep() et attend 2 secondes avant d'être réveillé.

6. État TERMINÉ : une fois que le thread a fini d'exécuter le code dans la méthode run(), le thread entrera dans l'état terminé. À l’état terminé, le thread ne s’exécutera plus.

En résumé, le statut du thread a un impact important sur l'exécution du programme. Comprendre les différents états et leur signification est crucial pour écrire des programmes multithread efficaces.

Matériaux de référence :

• Documentation officielle d'Oracle - État du thread Java : https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.State.html
• Introduction au multi-threading Java Tutoriel：https://www.journaldev.com/1162/java-thread-tutorial

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!