Une description détaillée des cinq états des threads Java ainsi que de leurs caractéristiques et performances dans les environnements multithreads

Expliquez en détail les cinq états des threads Java ainsi que leurs caractéristiques et performances dans un environnement multi-thread

Java est un langage de programmation orienté objet. Sa fonctionnalité multi-thread nous permet d'effectuer plusieurs tâches en même temps. , améliorant la simultanéité et la réactivité du programme. En Java, les threads ont cinq états différents, à savoir Nouveau, Exécutable, Bloqué, En attente et Terminé. Cet article présentera en détail les caractéristiques de ces cinq états et montrera les performances dans un environnement multithread à travers des exemples de code spécifiques.

1. Nouvel état (Nouveau)
L'état dans lequel un thread a été créé mais n'a pas encore commencé à s'exécuter est appelé le nouvel état. Dans l'état nouvellement créé, la méthode start() du thread n'a pas encore été appelée, donc l'exécution n'a pas réellement démarré. A ce stade, l'objet thread a été créé, mais le système d'exploitation ne lui a pas alloué de ressources d'exécution.

2. État exécutable (Runnable)
Une fois le thread appelé par la méthode start(), il entre dans l'état exécutable. Le thread dans cet état utilise le processeur pour effectuer ses tâches, mais peut être suspendu en raison d'autres threads de haute priorité, du manque de tranches de temps ou de l'attente d'une entrée/sortie. Dans l'état exécutable, les threads ont les caractéristiques suivantes :

1. Les threads dans cet état sont l'unité de base de la planification du système d'exploitation.
2. Plusieurs threads s'exécutent simultanément et des tranches de temps CPU sont allouées à chaque thread afin qu'ils s'exécutent alternativement.
3. La planification des threads est incontrôlable car elle est déterminée par le système d'exploitation.

Voici un exemple de code simple montrant l'état exécutable de deux threads :

class MyRunnable implements Runnable{
    public void run(){
        for(int i=0; i<10; i++){
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        Thread t2 = new Thread(new MyRunnable());
        
        t1.start();
        t2.start();
    }
}

Dans l'exemple ci-dessus, nous avons créé deux threads t1 et t2 et les avons démarrés simultanément. Puisque les deux threads s’exécutent simultanément, leur sortie alternera.

3. État bloqué (Bloqué)
Le thread entre dans l'état bloqué car il ne peut pas obtenir certaines ressources ou attend que certaines conditions soient remplies. Un thread dans un état bloqué ne consommera pas de temps CPU jusqu'à ce qu'il obtienne des ressources ou entre dans un état exécutable lorsque les conditions sont remplies.

Ce qui suit est un exemple de code simple montrant l'état bloquant d'un thread :

public class Main {
    public static void main(String[] args) {
        Object lock = new Object();
        
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1 is waiting");
                    lock.wait();
                    System.out.println("Thread 1 is running again");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(2000);
                
                synchronized (lock) {
                    System.out.println("Thread 2 is waking up Thread 1");
                    lock.notify();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        t1.start();
        t2.start();
    }
}

Dans l'exemple ci-dessus, nous avons créé deux threads t1 et t2, t1 entre en attente en appelant la méthode wait() pendant l'état d'exécution jusqu'à ce que t2 le réveille via la méthode notify(). La raison pour laquelle t1 est bloqué ici est qu'il ne peut pas continuer l'exécution tant que t2 n'émet pas de notification. Lorsque t2 envoie une notification, t1 débloque et rentre dans l'état exécutable.

4. État d'attente (Waiting)
Un thread entre dans l'état d'attente car il doit attendre que d'autres threads effectuent certaines actions spécifiques. Un thread en état d'attente attend jusqu'à ce qu'il soit notifié ou interrompu.

Ce qui suit est un exemple de code simple montrant l'état d'attente d'un thread :

public class Main {
    public static void main(String[] args) {
        Object lock = new Object();
        
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 1 is waiting");
                try {
                    lock.wait(); // 进入等待状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                
                System.out.println("Thread 1 is running again");
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(2000);
                
                synchronized (lock) {
                    System.out.println("Thread 2 is waking up Thread 1");
                    lock.notify(); // 唤醒等待的线程
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        t1.start();
        t2.start();
    }
}

Dans l'exemple ci-dessus, nous mettons le thread t1 dans l'état d'attente via la méthode lock.wait() jusqu'à ce que le thread t2 passe lock.notify ( ) méthode pour le notifier.

5. État terminé (Terminé)
Lorsqu'un thread termine sa tâche ou se termine en raison d'une exception, il entre dans l'état terminé. Un thread à l’état terminé ne s’exécute plus et ne peut pas être redémarré.

Voici un exemple de code simple montrant l'état de fin d'un fil :

public class Main {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for(int i=0; i<10; i++){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        });
        
        t1.start();
        
        try {
            t1.join(); // 确保线程执行完
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Thread 1 is terminated");
    }
}

Dans l'exemple ci-dessus, nous avons créé un fil t1 et l'avons démarré. Utilisez ensuite la méthode t1.join() pour vous assurer que le thread continue d'exécuter le code suivant une fois son exécution terminée.

Pour résumer, cet article présente les cinq états des threads Java ainsi que leurs caractéristiques et performances dans un environnement multi-thread. Pour la programmation multithread, il est crucial de comprendre les transitions et les caractéristiques des états des threads. L'utilisation d'états de thread appropriés peut rendre le programme plus efficace et plus fiable. J'espère que grâce à l'introduction de cet article, les lecteurs pourront mieux comprendre le mécanisme de fonctionnement des threads Java et utiliser correctement la programmation multithread dans des projets réels.

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!