Explication détaillée des cinq états des threads Java et des règles de transition d'état

Compréhension approfondie des cinq états des threads Java et de leurs règles de conversion

1 Introduction aux cinq états des threads
En Java, le cycle de vie d'un thread peut être divisé en cinq états différents, dont le nouvel état (NEW), état prêt (RUNNABLE), état en cours d'exécution (RUNNING), état bloqué (BLOCKED) et état terminé (TERMINATED).

1. Nouvel état (NEW) : Lorsque l'objet thread est créé, il est dans le nouvel état. À ce stade, l'objet thread a alloué suffisamment de ressources pour effectuer la tâche, mais n'a pas encore commencé à exécuter la méthode run().
2. État prêt (RUNNABLE) : lorsque le thread appelle la méthode start(), le thread entrera dans l'état prêt. Le thread à l'état prêt a les conditions pour s'exécuter et attend que le CPU alloue un segment de temps pour exécuter le code.
3. État d'exécution (RUNNING) : lorsque le thread à l'état prêt obtient le segment de temps CPU, il entre dans l'état d'exécution et commence à exécuter le code dans la méthode run(). Le thread restera en cours d'exécution jusqu'à ce qu'il se termine ou soit interrompu par un autre thread.

4. État bloqué (BLOCKED) : dans les circonstances suivantes, le thread entrera dans l'état bloqué :

   • La méthode sleep() est appelée et les ressources CPU sont activement abandonnées.
   • En attente de la libération d'une ressource, telle qu'une ressource verrouillée.
   • Les threads attendent la fin des autres threads dans la méthode join().
5. État terminé (TERMINATED) : une fois le thread terminé, il entre dans l'état terminé. Une fois que le thread a terminé l'exécution du code dans la méthode run(), ou que le thread est terminé en raison d'exceptions ou d'autres raisons, le thread entrera dans l'état terminé.

2. Règles de conversion entre les états
Il existe certaines règles de conversion entre les états des threads. Ci-dessous, nous présentons respectivement les règles de conversion entre chaque état.

1. Le nouvel état (NEW) est converti en état prêt (RUNNABLE) : lorsque l'objet thread est créé et que la méthode start() est appelée, le thread est converti du nouvel état à l'état prêt.
2. Convertir l'état prêt (RUNNABLE) à l'état d'exécution (RUNNING) : lorsque le thread obtient les ressources CPU, il passe de l'état prêt à l'état d'exécution.
3. Conversion de l'état d'exécution (RUNNING) à l'état de blocage (BLOCKED) : pendant l'exécution, le thread peut entrer dans l'état de blocage en raison de l'attente de la libération d'une ressource ou de la libération active des ressources du processeur.
4. Convertir l'état de blocage (BLOQUÉ) à l'état prêt (RUNNABLE) : lorsque la ressource que le thread attend est libérée ou que le temps d'attente expire, il passe de l'état de blocage à l'état prêt.
5. Conversion de l'état d'exécution (RUNNING) à l'état terminé (TERMINATED) : lorsque la méthode run() du thread est terminée ou que le thread est terminé en raison d'une exception, le thread passe de l'état d'exécution à l'état terminé.

3. Exemple de code

Ce qui suit est un exemple de code simple qui montre les règles de conversion entre les états du thread :

class MyThread extends Thread {
    
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println("线程执行完毕");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadStateDemo {

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        System.out.println("线程创建后状态：" + thread.getState());

        thread.start();
        System.out.println("调用start()方法后状态：" + thread.getState());

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("等待500ms后状态：" + thread.getState());

        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("调用join()方法后状态：" + thread.getState());
    }
}

Exécutez le code ci-dessus, vous pouvez voir le résultat comme suit :

线程创建后状态：NEW
调用start()方法后状态：RUNNABLE
等待500ms后状态：RUNNABLE
线程执行完毕
调用join()方法后状态：TERMINATED

Le code ci-dessus crée un héritage Objet Thread MyThread de la classe Thread. Dans le thread principal, nous pouvons observer les changements d’état de l’objet thread à différentes étapes.

En ayant une compréhension approfondie des cinq états des threads Java et de leurs règles de conversion, nous pouvons mieux comprendre les principes du multi-threading et améliorer encore la capacité de programmation simultanée. Dans le même temps, dans le processus de développement proprement dit, le jugement et le traitement de l'état des threads sont également très importants. J'espère que cet article pourra être utile à tout le monde.

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!