Quels sont les cinq états des threads Java-javaDidacticiel-php.cn

1. Cinq états des threads

Au niveau du système d'exploitation, tout thread a généralement cinq états, à savoir création, prêt, en cours d'exécution, bloqué et terminé.

(1) Nouvel état (NEW)

Lorsqu'un nouveau thread est créé à l'aide d'une méthode constructeur dans le programme, telle que new Thread(), le thread est dans l'état de création à ce moment, il a déjà le correspondant. l'espace mémoire et d'autres ressources. Mais l'exécution n'a pas encore commencé.

(2) État prêt (LECTURE)

Le démarrage d'un thread peut être réalisé en appelant la méthode start() de l'objet thread nouvellement créé. Lorsque le thread démarre, le thread entre dans l'état prêt (exécutable)

Le thread a les conditions d'exécution, mais comme le CPU n'a pas encore été alloué, il entre dans la file d'attente des threads et se met en file d'attente pour attendre le service du CPU. Une fois que le système sélectionne un objet thread à exécuter, l'objet passe de l'état d'attente à l'état d'exécution. Les actions sélectionnées par le système sont appelées « planification CPU ». Lorsque le thread obtient le CPU, il entre dans l'état d'exécution et exécute automatiquement sa propre méthode d'exécution.

(3) État d'exécution (RUNNING)

Un thread entre dans l'état d'exécution lorsqu'un thread à l'état prêt est appelé et occupe les ressources du processeur. A ce moment, la méthode run() de l'objet thread est automatiquement appelée.

(4) État bloqué (BLOQUÉ)

Un thread en cours d'exécution abandonnera le processeur et suspendra temporairement son exécution dans certaines circonstances particulières, telles qu'une suspension artificielle ou la nécessité d'effectuer des opérations d'entrée et de sortie fastidieuses, en entrant dans le. état de blocage.

Si vous utilisez sleep(), suspend(), wait() et d'autres méthodes à l'état exécutable, le thread sera bloqué. Lorsqu'il est bloqué, le thread ne peut pas entrer dans la file d'attente. Ce n'est que lorsque la cause du blocage est éliminée que le thread entre dans l'état prêt et retourne dans la file d'attente prête pour attendre. À ce moment, après avoir été sélectionné par le calendrier du processeur, il continuera. exécution à partir de la position d'arrêt d'origine.

Rappelez-vous : une fois le blocage éliminé, il revient à l'état prêt, et non à l'état de fonctionnement.

(5) TERMINÉ

Lorsqu'un thread appelle stop(), destroy() ou run() et termine l'exécution, le thread sera dans l'état terminal. Un thread dans un état mort n’a pas la possibilité de continuer à s’exécuter.

2. Les 6 états des threads Java

Le cycle de vie d'un thread en Java est divisé en 6 états. La classe Thread possède une propriété d'instance et une méthode d'instance spécifiquement utilisée pour enregistrer et obtenir l'état du thread. Parmi eux, les attributs d'instance utilisés pour enregistrer l'état de l'instance du thread sont :

// 以整数的形式保存线程的状态
private volatile int threadStatus = 0;
// 返回当前线程的状态，一个枚举类型值
public State getState() {
    return sun.misc.VM.toThreadState(threadStatus);
}

Copier après la connexion

Thread.State est une classe d'énumération interne qui définit 6 constantes d'énumération, représentant les 6 états des threads Java, comme suit :

public enum State {
    // 新建状态
    NEW,
    // 运行状态
    RUNNABLE,
    /**
     * 阻塞状态
     * Object.wait
     */
    BLOCKED,
    /**
     *  等待状态
     *  Object.wait
     *  Thread.join
     *  LockSupport.park
     */
    WAITING,
    /**
     *  限时等待状态
     *  Thread.sleep
     *  Object.wait
     *  Thread.join
     *  LockSupport.parkUntil
     *  LockSupport.parkNanos
     */
    TIMED_WAITING,
    // 终止状态
    TERMINATED;
}

Copier après la connexion

Il y en a quatre états communs, qui sont : l'état NEW (nouveau), l'état RUNNABLE (exécutable), l'état TERMINATED (terminé) et l'état TIMED_WAITING (attente limitée dans le temps).

(1) NEW state

Le code source Java explique l'état NEW comme suit : Les instances de thread de thread qui sont créées avec succès mais qui ne sont pas démarrées en appelant la méthode start() sont dans l'état NEW.

Bien sûr, une fois la méthode start() d'une instance de thread Thread appelée, son état passera de l'état NEW à l'état RUNNABLE. Cela ne signifie pas que le thread obtient immédiatement la tranche de temps CPU et l'exécute immédiatement. des opérations du système d’exploitation sont requises au milieu des opérations internes.

(2) RUNNABLE state

Après avoir appelé la méthode start() de l'instance Thread, si le thread obtient la tranche de temps CPU et démarre l'exécution à l'étape suivante, la JVM appellera de manière asynchrone la méthode run() du thread pour exécuter son code métier. Alors, que faisait la JVM avant que la méthode run() ne soit appelée de manière asynchrone ? Lorsque la méthode start() de l'instance Thread d'un thread Java est appelée, le thread correspondant dans le système d'exploitation n'entre pas dans l'état d'exécution, mais dans l'état prêt, et le thread Java n'a pas cet état prêt. Quel est l’état de préparation des threads dans le système d’exploitation ? La relation de conversion entre l'état du thread de la JVM et l'état du thread du système d'exploitation en arrière-plan est simplifiée comme suit :

Quels sont les cinq états des threads Java

Si un thread du système d'exploitation est à l'état prêt, cela signifie que "tout est prêt, tout ce dont nous avons besoin c'est du vent d'est", c'est-à-dire du fil. Les conditions d'exécution sont remplies, mais l'exécution ne peut pas encore avoir lieu. Le thread à l'état prêt doit attendre la planification du système. Une fois que l'état prêt est sélectionné par le système et obtient la tranche de temps CPU, le thread commence à occuper le CPU et commence à exécuter le code du thread. L'état du système d'exploitation du thread change et entre dans l'état d'exécution.

Lorsque le thread en cours d'exécution dans le système d'exploitation utilise la tranche de temps CPU, il reviendra à l'état prêt et attendra la prochaine planification du CPU. De cette façon, le thread du système d'exploitation est planifié à plusieurs reprises par le système entre l'état prêt et l'état d'exécution. Cette situation continuera jusqu'à ce que l'exécution logique du code du thread soit terminée ou que le thread se termine anormalement. À ce stade, l'état du système d'exploitation du thread a de nouveau changé, entrant dans l'état final du thread - l'état TERMINATED.

L'état prêt et l'état d'exécution sont tous deux des états de thread dans le système d'exploitation. Dans le langage Java, ces deux états ne sont pas subdivisés, mais fusionnés en un même état : l'état RUNNABLE. Par conséquent, dans la classe d'énumération Thread.State, l'état prêt et l'état d'exécution du thread ne sont pas définis, seul l'état RUNNABLE est défini. C'est là que l'état du thread Java diffère de l'état du thread dans le système d'exploitation.

Lorsque l'instance Thread est dans l'état NEW, une fois la méthode start() appelée, le thread passera à l'état RUNNABLE. Malgré cela, la méthode run() du thread peut ne pas être exécutée simultanément immédiatement. L'exécution simultanée doit être démarrée une fois que le thread a obtenu la tranche de temps CPU.

(3) État TERMINATED

Lorsque le thread dans l'état RUNNABLE termine d'exécuter la méthode run(), il entrera dans l'état de terminaison TERMINATED. Bien entendu, si une exception d'exécution se produit lors de l'exécution de la méthode run() et n'est pas interceptée, la méthode run() se terminera anormalement et le thread deviendra également TERMINATED.

(4) TIMED_WAITING state

Le thread est dans un état d'attente spécial Pour être précis, le thread est dans un état d'attente limité dans le temps. Les opérations qui peuvent mettre un thread dans un état d'attente limité dans le temps sont à peu près les suivantes :

Thread.sleep(int n) : fait entrer le thread actuel dans un état d'attente limité dans le temps, et le temps d'attente est n millisecondes.
Object.wait() : préempte le verrouillage du moniteur de l'objet avec une limite de temps.
Thread.join() : fusion de fils de discussion limitée dans le temps.
LockSupport.parkNanos() : Laissez le thread attendre, le temps est en nanosecondes.
LockSupport.parkUntil() : laissez le fil attendre et l'heure peut être définie de manière flexible.