« Salut Amigo ! »
« Nous allons ouvrir un nouveau sujet : les fils de discussion. »
"Commençons. Aujourd'hui, nous allons examiner les états par lesquels un objet Thread passe (ou pourrait passer) lorsqu'un thread est en cours d'exécution."
"Combien d'états pouvez-vous nommer en ce moment, Amigo ?"
"Deux. Le premier est un thread avant que la méthode start() ne soit appelée : l'objet existe, mais le thread n'est pas encore actif. Et le second est après que la méthode start() a été appelée : lorsque le thread fait quelque chose important."
"Vous avez raison, il y a une telle distinction. Ces états sont appelés nouveaux et en cours d'exécution , mais ce n'est que le début."
"Tout d'abord, à un moment donné, le thread finira de s'exécuter, ce qui signifie qu'il peut y avoir une situation où l'objet Thread existe, mais le thread n'est pas dans l'état nouveau ou en cours d'exécution. "Cet état, où le thread a fini de s'exécuter, est appelé résilié ."
"Mais il y a plus. N'oubliez pas qu'à un moment donné, un seul thread est en cours d'exécution. Ce qui semble être un travail simultané est en fait le processeur qui saute constamment d'un thread à l'autre. Il existe un état distinct lorsque le thread semble être en cours d'exécution, mais attend en fait son tour : c'est ce qu'on appelle ready-to-run . Lorsqu'un thread fonctionne, il passe constamment de running à ready , puis revient à running lorsqu'il redevient actif. »
"Immédiatement après l'appel de la méthode start (), le thread se voit attribuer le statut prêt à fonctionner et placé dans une liste partagée de threads entre lesquels la JVM bascule."
"Ce n'est pas trop difficile. Avant qu'il ne commence à s'exécuter, il a le nouvel état. Une fois qu'il a terminé, il est terminé . Lorsqu'il est en cours d'exécution, le thread est à l' état d'exécution ; puis lorsqu'il attend, il est à l' état prêt ."
"Votre brièveté est incroyable, mais vous avez raison."
"Mais il y a plus. Le thread peut être bloqué. Par exemple, lorsque vous entrez dans un bloc synchronisé . Si un thread atteint un bloc de code marqué comme synchronisé et qu'un autre thread l'utilise, alors notre thread entrera dans l' état bloqué et attendra pour que le mutex (verrou) de l'objet soit libéré."
"Voici à quoi ressemble cette situation avec les états :"
"Mais il y a plus. Il existe également un état distinct appelé attente . C'est lorsqu'un thread n'est pas bloqué , mais également pas prêt . Par exemple, lorsque vous appelez la méthode join () sur un autre thread. "
Lorsque nous appelons join() sur un autre objet Thread, c'est comme si notre thread le « rejoignait », mais en réalité il attend juste que l'autre thread se termine.
"En outre, il existe également la méthode wait () (du trio de méthodes wait/notify/notifyAll), qui fait passer un thread à l' état d'attente lorsqu'il est appelé."
"Waouh."
"Attendez une minute! Il y a encore plus. Un thread peut dormir en appelant la méthode sleep, par exemple. Il existe également un état séparé pour cela. Cela s'appelle " attente temporisée " . un temps limité. Si vous appelez une méthode d'attente avec un paramètre, tel que wait(timeout) ou join(timeout), alors le thread entrera dans l'état timed-waiting.
"Voici le schéma complet :"
« Hmm. C'est tout ? Ou y a-t-il 10 États plus intéressants ? »
"Pour l'instant, c'est tout."
"En pratique, vous pouvez simplement retenir le premier schéma. C'est plus simple. Mais le second est plus précis."
"Curieusement, il existe de nombreux diagrammes d'état de thread sur Internet, et ils sont tous différents."
« C'est pourquoi je vous ai donné ce schéma, c'est le plus complet et le plus correct. »
"Dans ce diagramme, les états prêt et en cours d'exécution sont combinés dans un seul bloc appelé exécutable. Savez-vous pourquoi ?"
"Non. C'est la première fois que je vois quelque chose comme ça."
"La classe Thread a une classe interne appelée State , ainsi qu'une méthode publique State getState() ."
public enum State
{
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}"Vous pouvez toujours appeler la méthode getState () sur un objet Thread et connaître son état actuel. Et, bien sûr, ce sera l'une des valeurs d'énumération State."
"Je vois. Donc, les états réels sont à l'intérieur de la JVM, mais il y a aussi des états auxquels vous pouvez accéder via du code Java en utilisant la méthode State getState()."
"Et dans quelles circonstances pourrais-je l'utiliser ?"
"Très probablement, jamais."
"Mais vous devez savoir ce qui se passe à l'intérieur des threads. Sinon, vous aurez beaucoup de bugs, et vous ne pourrez même pas deviner ce qui les cause."
"De plus, les employeurs adorent poser des questions sur les états de Thread lors des entretiens."
GO TO FULL VERSION