Java a plusieurs états de thread

Java a 6 états de thread : initial (NEW), en cours d'exécution (RUNNABLE), bloqué (BLOCKED), en attente (WAITING), délai d'attente (TIMED_WAITING) et terminé (TERMINATED). Utilisez le mot-clé new pour créer un nouveau thread, mais la méthode start() n'a pas été appelée. Le thread est dans l'état new ; l'état bloqué indique que le thread attend le verrouillage du moniteur et est bloqué dans l'état ; le thread qui entre dans l'état d'attente doit attendre que d'autres threads prennent une décision. Une action spécifique (notification ou interruption).

L'environnement d'exploitation de ce tutoriel : système windows7, version java8, ordinateur Dell G3.

JavaL'état des threads est divisé en 6 types :

1 Initial (NOUVEAU) : Un nouvel objet thread est créé, mais la méthode start() n'a pas été créée. encore appelé.
2. Run (RUNNABLE) : Dans les threads Java, les deux états prêt et en cours d'exécution sont généralement appelés "en cours d'exécution".
Une fois l'objet thread créé, d'autres threads (tels que le thread principal) appellent la méthode start() de l'objet. Le thread dans cet état est situé dans le pool de threads exécutables, en attente d'être sélectionné par la planification des threads pour obtenir le droit d'utiliser le CPU. Il est actuellement dans l'état prêt. Le thread à l’état prêt devient en cours d’exécution après avoir obtenu la tranche de temps CPU.
3. BLOCKED : Indique que le fil est bloqué dans la serrure.
4. En attente : Le thread entrant dans cet état doit attendre que d'autres threads effectuent certaines actions spécifiques (notification ou interruption).
5. Timeout wait (TIMED_WAITING) : Cet état est différent de WAITING, il peut revenir tout seul après le temps spécifié.
6. TERMINATED(TERMINATED) : Indique que le thread a terminé son exécution.

Ces 6 états sont définis dans l'énumération State de la classe Thread. Vous pouvez visualiser le code source pour une correspondance individuelle.

1. Diagramme d'état du thread

2. Description détaillée de l'état

1. État initial (NOUVEAU)

L'implémentation de l'interface Runnable et l'héritage de Thread peuvent obtenir une classe de thread lorsqu'une instance de new sort. , le thread entrera dans l'état initial.

2.1. État Prêt (PRÊT ou RUNNABLE)

• L'état prêt signifie simplement que vous êtes qualifié pour exécuter. Si le planificateur ne vous sélectionne pas, vous serez toujours dans l'état Prêt.

• Appelez la méthode start() du fil, et ce fil entre dans l'état Prêt.

• La méthode sleep() du thread actuel se termine et la méthode join() des autres threads se termine. Une fois la saisie de l'utilisateur terminée, un thread obtient le verrou d'objet et ces threads entreront également dans le Prêt. État.

• La tranche de temps du thread actuel est épuisée, la méthode rendement() du thread actuel est appelée et le thread actuel entre dans l'état Prêt.

• Une fois que le thread dans le pool de verrouillage a obtenu le verrouillage de l'objet, il entre dans l'état Prêt.

2.2. État d'exécution (RUNNABLE ou RUNNING)

L'état du thread lorsque le planificateur de threads sélectionne un thread du pool exécutable comme thread actuel. C'est également le seul moyen pour un thread d'entrer dans l'état d'exécution.

3. État bloqué (BLOCKED)

L'état bloqué est l'état dans lequel le thread se bloque lors de la saisie de la méthode ou du bloc de code (acquisition du verrou) modifié par le mot-clé synchronisé.

4. En attente(WAITING)

Les threads dans cet état ne se verront pas attribuer de temps d'exécution du processeur. Ils doivent attendre d'être explicitement réveillés, sinon ils seront dans un état d'attente indéfini.

5. Délai d'attente(TIMED_WAITING)

Les threads dans cet état ne se verront pas attribuer de temps d'exécution du processeur, mais ils n'ont pas besoin d'attendre indéfiniment pour être explicitement réveillés par d'autres threads. Ils se réveilleront automatiquement après un certain temps. .

6. TERMINÉ

• Lorsque la méthode run() du thread est terminée, ou lorsque la méthode main() du thread principal est terminée, nous la considérons comme terminée. Cet objet thread peut être vivant, mais ce n'est plus un thread exécuté séparément. Une fois qu'un thread est terminé, il ne peut pas être relancé.

• L'appel de la méthode start() sur un thread terminé lèvera une exception java.lang.IllegalThreadStateException.

3. Waiting Queue

• Avant d'appeler les méthodes wait(), notify() d'obj, le verrou obj doit être obtenu, ce qui signifie qu'il doit être écrit dans le segment de code synchronisé (obj).
• Étapes et diagrammes liés à la file d'attente

• Le fil 1 acquiert le verrou de l'objet A et utilise l'objet A.

• Thread 1 appelle la méthode wait() de l'objet A.

• Thread 1 libère le verrou de l'objet A et entre immédiatement dans la file d'attente.

• Les objets dans le pool de verrouillage se disputent le verrouillage de l'objet A.

• Thread 5 obtient le verrou de l'objet A, entre dans le bloc synchronisé et utilise l'objet A.

• Thread 5 appelle la méthode notifyAll() de l'objet A, réveille tous les threads et tous les threads entrent dans la file d'attente de synchronisation. Si le thread 5 appelle la méthode notify() de l'objet A, un thread sera réveillé. On ne sait pas qui sera réveillé et le thread réveillé entrera dans la file d'attente de synchronisation.

• La méthode notifyAll() est synchronisée et se termine, et le thread 5 libère le verrou de l'objet A.

• Les threads de la file d'attente de synchronisation sont en compétition pour le verrouillage de l'objet, mais on ne sait pas quand le thread 1 peut le récupérer.

4. Statut de la file d'attente de synchronisation

• Lorsque le thread actuel veut appeler la méthode de synchronisation de l'objet A, il constate que le verrou de l'objet A est occupé par un autre thread. la file d'attente de synchronisation. En bref, la file d'attente de synchronisation est remplie de threads qui veulent rivaliser pour les verrous d'objets.
• Lorsqu'un thread 1 est réveillé par un autre thread 2, le thread 1 entre dans la file d'attente de synchronisation pour concourir pour le verrouillage de l'objet.
• File d'attente de synchronisation est un concept qui n'existe que dans un environnement synchronisé. Un objet correspond à une file d'attente de synchronisation.
• Une fois le temps d'attente du thread écoulé ou réveillé par notify/notifyAll, il entrera dans la file d'attente de synchronisation pour concourir pour le verrou, s'il obtient le verrou, il entrera dans l'état RUNNABLE, sinon il entrera dans l'état BLOCKED et. attendez d'obtenir la serrure.

5. Comparaison de plusieurs méthodes

• Thread.sleep(long millis), cette méthode doit être appelée par le thread actuel. Le thread actuel entre dans l'état TIMED_WAITING, mais ne libère pas le verrou de l'objet après. millis, le thread se réveille automatiquement et passe à l'état Prêt. Rôle : la meilleure façon de donner à d'autres threads une chance de s'exécuter.

• Thread.yield(), cette méthode doit être appelée par le thread actuel. Le thread actuel abandonne la tranche de temps CPU acquise, mais ne libère pas la ressource de verrouillage, et passe de l'état d'exécution à l'état prêt, permettant au système d'exploitation de sélectionner à nouveau le thread. Fonction : laissez les threads avec la même priorité s'exécuter à tour de rôle, mais il n'y a aucune garantie qu'ils s'exécuteront à leur tour. En pratique, il n'y a aucune garantie que rendement() atteindra l'objectif de rendement, car le thread produisant peut être à nouveau sélectionné par le planificateur de threads. Thread.yield() ne provoque pas de blocage. Cette méthode est similaire à sleep(), sauf que l'utilisateur ne peut pas spécifier la durée de la pause.

• thread.join()/thread.join(long millis), le thread actuel appelle la méthode de jointure de l'autre thread t, le thread actuel entre dans l'état WAITING/TIMED_WAITING, le thread actuel ne sera pas publié le verrouillage de l'objet détenu. Lorsque le thread t termine l'exécution ou que le temps millis expire, le thread actuel entre généralement dans l'état RUNNABLE et peut également entrer dans l'état BLOCKED (car la jointure est implémentée en fonction de l'attente).

• obj.wait(), le thread actuel appelle la méthode wait() de l'objet, le thread actuel libère le verrou de l'objet et entre dans la file d'attente. Fiez-vous à notify()/notifyAll() pour vous réveiller ou attendez (long timeout) pour vous réveiller automatiquement lorsque le délai d'expiration expire.

• obj.notify() réveille un seul thread en attente sur ce moniteur d'objets, le choix est arbitraire. notifyAll() réveille tous les threads en attente sur ce moniteur d'objets.

• LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkJusqu'à (longs délais), le thread actuel entre dans l'état WAITING/TIMED_WAITING. Par rapport à la méthode d'attente, le thread peut entrer dans l'état WAITING/TIMED_WAITING sans obtenir le verrou et doit être réveillé via LockSupport.unpark (thread thread).

Pour plus de connaissances liées à la programmation, veuillez visiter : Enseignement de la programmation ! !

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!