Introduction au cycle de vie des threads en Java
Un fil connaît de nombreuses phases du cycle de vie. Tels que, un fil vient dans le monde, a commencé, court et après cela décède. Le diagramme suivant explique le cycle de vie complet du fil.
- Constructeur de thread produit un thread à travers un nouvel état.
- Appeler begin la méthode dans Thread peut passer à travers l'état exécutable.
- Thread Scheduler concernant Java exécute ce thread lorsque le processeur reçoit.
- Lorsque le thread passe à un état bloqué, il va s'exécuter à nouveau car il revient à un état exécutable.
- Si la méthode d'attente est appelée thread, elle passe à l'attente de l'état, elle passe à l'état exécutable peu de temps après qu'elle deviendra une notification dans Informer ainsi qu'une méthode de notification globale.
- Le thread se termine une fois la méthode d'exécution terminée.
Qu'est-ce que le fil?
Un thread est défini au niveau du système d'exploitation. Et le langage Java, ainsi que tous les autres langages, utilise, exploite, le service fourni par le système d'exploitation. Du point de vue du développeur, un thread est un ensemble d'instructions que nous allons écrire notre application et exécuter d'une certaine manière. Une application elle-même peut être composée de plusieurs threads. Différents threads peuvent être exécutés en même temps. La JVM (Java Virtual Machine) fonctionne avec plusieurs threads. Il existe des threads pour la récupération de place. Il existe des threads pour le compilateur Just in Time et d'autres threads techniques.
États du cycle de vie des threads en Java
Voici les différents états du cycle de vie des threads en Java:
1. Nouveau: un nouveau thread démarre son cycle de vie dans le nouvel état. Il reste dans cet état avant que le programme ne commence le thread. En outre, il est connu comme un fil créé.
2. Exécutable: après qu'un thread récemment né puisse commencer, le thread se transforme en exécutable. Un thread avec cet état est considéré comme effectuant son processus.
3. En attente: Parfois, une transition de thread vers l'attente autour de l'état même si le thread attend qu'un autre thread exécute une activité. Un thread ne passe à l'état exécutable que si un thread supplémentaire indique le thread en attente de continuer à fonctionner.
4. Attente chronométrée: un thread exécutable peut facilement attendre en temps voulu pour que l'état obtienne un intervalle de temps spécifique. Un thread avec cet état transitions retourne à l'état exécutable une fois cet intervalle de points expiré ou si l'événement qu'il attend vraiment se produit.
5. Terminé: un thread exécutable entre dans l'état terminé car il accomplit sa tâche ou se termine.
Comment créer un fil en Java?
La façon la plus simple de créer un thread en Java consiste à utiliser le modèle exécutable. Vous devez d'abord créer une instance de l'interface Runnable, ce qui est très simple; il n'y a qu'une seule méthode à implémenter. Ensuite, nous transmettons cette instance au constructeur de la classe Thread. Et puis nous appelons simplement la méthode start () de cet objet thread créé, pour lancer un nouveau thread qui va exécuter la tâche encapsulée dans notre objet Runnable.
Donc, nous créons d'abord une instance d'un Runnable. Il n'y a qu'une seule méthode à implémenter, qui est appelée la méthode run (). C'est le modèle Java 7 pour le faire, avec une instance d'une classe anonyme. Mais nous pouvons également utiliser une expression lambda pour implémenter un Runnable car il n'y a qu'une seule méthode dans l'interface Runnable.
Créons des threads sur des exemples très simples
Nous allons voir ce qui peut mal tourner avec une condition de concurrence avec du code non synchronisé qui devrait être synchronisé et nous allons corriger notre code en utilisant la synchronisation. Ce premier exemple est très simple, c'est très basique. Il s'agit simplement de créer une tâche.
Production:
Une tâche est une instance de l'interface Runnable, appelons-la runnable, et nous pouvons implémenter cette interface à l'aide d'une expression lambda. Cette tâche est donnée à un nouveau thread et exécutée dans le contexte de ce thread. Nous allons donc simplement imprimer le nom du thread qui exécute cette tâche. Je cours dans… Thread.currentThread () est une méthode statique de la classe Thread qui renvoie le thread exécutant la tâche en cours. Et il suffit d'appeler getName () sur cet objet thread pour renvoyer le nom d'un thread. Ensuite, après avoir créé une instance de thread t = nouveau thread. Passer ce runnable comme paramètre. Donc, ce thread va exécuter ce morceau de code. Et pour le lancer. t.start () c'est la méthode start () que nous devons appeler. Ce que nous pouvons également faire, c'est donner un nom explicite à ce Thread en utilisant t.setName («Mon thread»). Et maintenant, nous pouvons exécuter ce code. Maintenant, au lieu d'appeler la méthode start (), nous appelons la méthode run (), et si nous exécutons ce code, le problème est que la tâche est correctement exécutée, mais elle n'est pas exécutée dans le thread que nous avons créé. Il est exécuté dans le thread principal qui est le thread exécutant la méthode principale. Cette méthode run () ne doit donc pas être appelée si nous voulons lancer un nouveau thread.
Production:
Méthodes de cycle de vie des threads en Java
Les méthodes décrites par simplement Thread sont présentées dans le tableau.
| Types de données | Noms des méthodes de thread |
| Chaîne |
getName () Renvoyer le nom de ce fil |
| int | obtenir la priorité ()
Renvoie la priorité du thread |
| booléen | est vivant()
Teste si ce thread est toujours en cours d'exécution |
| néant | joindre()
Attend la mort de ce fil (terminer) |
| néant | courir()
Chaque fois que ce thread a été construit en utilisant un objet Runnable individuel, après quoi la méthode run de l'objet Runnable est généralement appelée; ou bien, cette méthode ne sera rien aussi bien que, retourne. Chaque fois que la classe de thread peut être étendue ainsi que, la méthode run () est écrasée pendant la sous-classe, puis une méthode run () écrasée est appelée. |
| néant | setName ( String name )
Modifie le nom avec ce fil pour devenir comparable au nom de l'argument. |
| vide statique | sleep ( long millis ) throws Interrupted / Exception Provoque le repos du thread en cours d'exécution la quantité requise de millisecondes. |
| vide statique | sommeil ( longs millis, nanos int ) lève InterruptedException
Il provoque la mise en veille du thread en cours d'exécution (arrêt de l'exécution) pendant la quantité requise de millisecondes ainsi que la quantité particulière de nanosecondes. |
| néant | début()
Déclenche ces threads pour démarrer l'exécution; la machine virtuelle Java appelle la méthode d'exécution de ce thread. |
| vide statique | rendement()
Déclenche l'objet thread actuellement en pause et autorise l'exécution de threads supplémentaires. |
| fil statique | currentThread ()
Renvoie une mention de l'objet thread en cours d'exécution. |
Conclusion
- Simple à utiliser avec des fils, extrêmement difficile à saisir.
- La conception de classes contenant des méthodes pouvant être sécurisées par thread est difficile.
- Lire: JavaDoc pour obtenir la classe java.lang.Thread
Article recommandé
Cela a été un guide du cycle de vie des threads en Java. Ici, nous discutons de ce qu'est le fil? et différents états du cycle de vie des threads ainsi que la création de threads en java. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus -
- Cadres en Java
- Motifs d'étoiles en Java
- Fusionner le tri en Java
- Meilleurs compilateurs Java
- Méthode statique en PHP