Introduction détaillée du cycle de vie des threads Java et du code d'exemple

Lorsqu'un thread est créé et démarré, il n'entre pas dans l'état d'exécution dès qu'il est démarré et qu'il est toujours dans l'état d'exécution. Au cours de son cycle de vie, il doit passer par cinq États: "Nouveau", "Runnable", "Running", "Blocké" et "Dead". Une fois le thread créé, il est impossible qu'il occupe le CPU et l'exécute indépendamment. Il doit basculer entre plusieurs threads, il est donc basculé entre l'exécution et le blocage la plupart du temps.

1. L'état du fil

Il existe plusieurs états différents de l'existence d'un fil, comme suit:

1. Nouveau statut
2. Statut prêt
3. État de course
4. Statut mort
5. Statut non runnable
   

1. Nouveau statut

Le nouvel état est un état où le fil a été créé mais n'a pas commencé à fonctionner. Cet état permet au thread d'exécuter en appelant la méthode start () du thread.

2. Statut de course

L'état coulable peut être appelé l'état de course préparatoire ou la file d'attente. Cet état peut permettre au thread d'exécuter en appelant la méthode start () du thread.
Le planificateur de thread détermine les threads à exécuter et combien de temps le thread fonctionnera.

3. Statut d'exécution

Si un thread s'exécute, il est à l'état en cours d'exécution.

4. Statut mort

Une fois qu'un fil entre dans l'état mort, il ne peut plus fonctionner.

5. Statut non runnable

1. Un thread en cours d'exécution peut être transformé à l'état non runnable, en fonction de la situation de course.
2. Un fil peut également maintenir l'état non runnable jusqu'à ce que la condition satisfaite apparaisse.
3. Un fil avec un état non coulable ne peut pas sauter directement à l'état de course, mais doit d'abord être converti à l'état coulable.
4. Dormir: le temps spécifié pour le sommeil en fil.
5. Blocage d'E / S: le fil attend jusqu'à ce que l'opération de blocage soit terminée.
6. Rejoignez le blocage: le thread attend jusqu'à ce qu'un autre thread s'exécute.
7. En attente de notification: le thread attend la notification d'un autre thread.
8. Blocage du mécanisme de verrouillage: le fil attend jusqu'à ce que le verrouillage spécifié soit libéré et que le verrou est obtenu.

La machine virtuelle Java JVM exécute des threads en fonction des principes de priorité et de planification du thread.

2. Planificateur de threads

Dans JVM, la mise en œuvre du planificateur de threads est généralement basée sur les deux stratégies suivantes:

Stratégie de planification préemptive Stratégie de planification de partage de temps ou stratégie de planification de la ronde

L'implémentation d'un planificateur de threads est indépendante de la plate-forme, donc la planification des threads est imprévisible.

3. Priorité des fils

Le JVM attribue une priorité à chaque fil nouvellement créé.

Niveau 0: c'est la priorité la plus basse
Niveau 5: C'est la priorité normale
Niveau 10: C'est la priorité la plus élevée

Pour enregistrer ces valeurs, la classe de thread a trois variables correspondantes:

1. Public Static Final int min_priority
2. Public statique final int norm_priority
3. Public Static Final int max_priority

Un fil héritera d'abord de la priorité de son fil parent. La priorité par défaut de chaque thread est le niveau 5 (priorité normale), et la priorité par défaut du thread principal est le niveau 5.

La priorité du thread peut être définie via la méthode SetPriority (priority).

Public final vide setpriority (intring)
public void getPriority ();

Un thread défini par l'utilisateur a un thread de nom de thread par défaut + numéro de séquence, et le numéro de séquence démarre à partir de 0, tel que le premier thread est Thread0.
Le nom de thread peut être défini via la méthode setName (nom de chaîne) et le nom de thread peut être obtenu à l'aide de la méthode getName ().

SetName du vide final public (nom de la chaîne)
Public Final String getName ().

Exemple

Voyons un exemple ci-dessous:

 package Demo.ch; public class userthread étend thread {userthread () {super (); } Userthread (name de chaîne) {super (name); } public void run () {System.out.println ("Thread a commencé à fonctionner .."); } public static void main (String [] args) {userthread thread1 = new Userthread ("thread1"); Userthread thread2 = new Userthread ("thread2"); System.out.println ("Thread 1 Nom initial et priorité"); System.out.println ("name:" + thread1.getName ()); System.out.println ("Priorité:" + Thread1.getPriority ()); System.out.println ("Thread 2 Nom initial et priorité"); System.out.println ("Name:" + Thread2.GetPriority ()); System.out.println ("Priorité:" + Thread2.GetPriority ()); System.out.println (""); thread1.setPriority (6); thread2.setPriority (9); System.out.println ("Thread 1 Nom initial et priorité"); System.out.println ("name:" + thread1.getName ()); System.out.println ("Priorité:" + Thread1.getPriority ()); System.out.println ("Thread 2 Nom initial et priorité"); System.out.println ("name:" + thread2.getName ()); System.out.println ("Priorité:" + Thread2.GetPriority ()); System.out.println (""); thread1.start (); thread2.start (); pour (int i = 0; i <5; i ++) System.out.println ("Méthode principale I Value:" + i); }}

Résultat de sortie:

 Thread 1 Nom initial et Nom de priorité: Thread1Priority: 5Thread 2 Nom initial et Nom de priorité: Thread2Priority: 5thread 1 Nom initial et Nom de priorité: Thread1Priority: 6thread 2 Nom initial et Nom de priorité: Thread2Priority: Méthode 9main I VALUE: Méthode 0Mai

Merci d'avoir lu, j'espère que cela peut vous aider. Merci pour votre soutien à ce site!