Le cycle de vie d'un thread est divisé en plusieurs étapes

5 étapes : 1. New, qui est le thread qui vient d'être créé à l'aide de la méthode new ; 2. Ready, qui est après avoir appelé la méthode start() du thread. À ce stade, le thread est en phase. d'attendre que le CPU alloue des ressources ; 3. En cours d'exécution, lorsque le thread prêt est planifié et obtient des ressources CPU, il entre dans l'état d'exécution ; certaines raisons : 5. Destruction, le thread s'exécute normalement. Une fois terminé ou si le thread est terminé de force à l'avance ou si une exception se produit, le thread sera détruit.

L'environnement d'exploitation de ce tutoriel : système Windows 7, ordinateur Dell G3.

Le cycle de vie d'un thread contient 5 étapes, dont : nouveau, prêt, en cours d'exécution, bloqué et détruit. Le diagramme du cycle de vie complet est le suivant :

Lorsqu'un thread entre dans l'état d'exécution, le système d'exploitation général utilise une méthode préemptive pour permettre au thread d'obtenir le CPU. Par conséquent, le processeur doit basculer entre plusieurs threads, de sorte que l'état du thread basculera entre en cours d'exécution, bloqué et prêt plusieurs fois.

1. Nouveau (nouveau)

New : En utilisant la méthode new, new sort du thread À ce stade, seule la machine virtuelle JAVA lui alloue de la mémoire et initialise les valeurs. ​​des variables membres. Ce n'est qu'un objet pour le moment.

2. Runnable

Ready : Après avoir appelé la méthode start() du thread, le thread est actuellement en train d'attendre que le CPU alloue les ressources. Les ressources CPU gagneront en premier. Démarrez l'exécution ;
Le thread entre dans l'état prêt, La machine virtuelle JAVA crée une pile d'appels de méthode et un compteur de programme pour cela . L'exécution des threads est contrôlée par la plateforme sous-jacente et présente un certain degré de caractère aléatoire.

3. En cours d'exécution

En cours d'exécution : lorsque le thread prêt est planifié et obtient des ressources CPU, il entre dans l'état d'exécution. La méthode run définit le fonctionnement et la fonction du thread (lorsque dans When ; le thread à l'état prêt obtient le CPU, il exécutera la méthode run())
Pour un CPU monocœur (ou un core), il ne peut exécuter qu'une seule instruction à la fois, et la JVM réalise le multi-threading en changeant rapidement de thread pour exécuter des instructions Oui, un vrai processeur peut traiter une instruction en même temps, mais cette vitesse de commutation est si rapide que nous ne la remarquerons pas du tout. Afin de restaurer la position d'exécution correcte après le changement de thread, chaque thread dispose d'un compteur de programme indépendant. Les compteurs entre chaque thread ne s'influencent pas et sont stockés indépendamment.
Lorsqu'un thread commence à s'exécuter, il ne peut pas maintenir le CPU tout le temps (sauf si le corps d'exécution du thread est très court et que l'exécution se termine instantanément). Par conséquent, le thread doit être interrompu pendant l'exécution afin de permettre à d'autres threads d'accéder au CPU pour l'exécution. Les détails de la planification des threads dépendent de la stratégie adoptée par la plateforme sous-jacente.

4. Bloqué

Bloqué : lorsqu'il est en cours d'exécution, le fil en cours d'exécution peut être bloqué pour certaines raisons. Les raisons sont les suivantes :

1.等待I/O流的输入输出
2.等待网络资源，即网速问题
3.调用sleep（）方法，需要等sleep时间结束
4.调用wait（）方法，需要调用notify（）唤醒线程
5.其他线程执行join（）方法，当前线程则会阻塞，需要等其他线程执行完。

Le diagramme de changement d'état est le suivant :

5. Détruit (terminé)

Si le thread termine son exécution normale ou si le thread est terminé de force dans advance ou une exception se produit, cela se termine, alors le thread sera détruit et les ressources seront libérées.

1. La méthode run()/call() est exécutée et le thread se termine normalement ;
2. Le thread renvoie une exception ou une erreur non interceptée
3. Appelez directement la méthode stop() du thread pour terminer le thread ; - Cette méthode peut facilement conduire à une impasse et n'est généralement pas recommandée.

Connaissances approfondies : tranche de temps CPU

Il y a un oscillateur à cristal au niveau du système d'exploitation, qui est un peu comme un moine qui continue de frapper l'horloge à chaque courte période de temps, en se divisant. le temps CPU en une tranche de temps ; chaque thread récupère en fait constamment les tranches de temps une par une ; une fois que la tranche de temps atteint le point, il doit encore la récupérer (pour s'assurer que tous les threads ont la possibilité de récupérer le CPU pour exécuter leur propre logique ; équité)

Nouvel état

Jetons un coup d'œil au morceau de code suivant :

Thread t1 = new Thread();

La création ici n'est créée qu'au niveau du langage de programmation de JAVA, mais au niveau du système d'exploitation, le réel le fil n'a pas encore été créé. Ce n'est que lorsque nous appelons la méthode start() que le thread sera créé et entrera dans l'état Runnable. Ce n'est que lorsque nous appellerons la méthode start() que le fil de discussion sera créé

Pour plus de connaissances connexes, veuillez visiter la colonne FAQ !

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!