Cycle de vie du thread en Java

Principes de base des threads Java :

Un thread en Java facilite l'exécution de plusieurs activités au sein d'un même processus. Il est considéré comme un processus léger. Un thread peut également être défini comme une séquence d'instructions exécutées. Chaque thread en Java a sa propre pile, son compteur de programme et ses variables locales. Les threads Java peuvent également être une série imbriquée d'appels de méthode. La mémoire, l'état par processus et les fichiers sont partagés par les threads.

Utilisations des threads en Java :

• • Pour effectuer un traitement en arrière-plan ou asynchrone
  • Pour améliorer la sensibilité des applications GUI
  • Mettre en œuvre les côtés positifs des systèmes multiprocesseurs
  • Pour rationaliser la logique de programmation en cas d'existence de plusieurs

Il existe deux chemins d'exécution lorsqu'un thread est appelé. L'un des deux chemins est utilisé pour l'exécution du thread et l'autre suivra l'instruction succédant à l'invocation du thread. Chaque thread en Java dispose d'un espace mémoire et d'une pile distincts.

Les facteurs de risque rencontrés lors de l'utilisation de threads dans les codes Java sont les suivants.

• Une bonne coordination entre les threads est requise dans les cas où les threads accèdent à des variables communes pour afficher les données de manière cohérente.
• Les performances et la maintenance des threads, s'ils sont surutilisés dans les programmes, deviennent difficiles.

Cycle de vie des threads en Java :

À tout instant de l'exécution du programme, les threads en Java existent dans l'un des états mentionnés ci-dessous.

1. Nouveau
2. Bloqué
3. Exécutable
4. Attente chronométrée
5. En attendant
6. Résilié

Une vue détaillée du cycle de vie du thread en Java

Nouveau fil :

Le thread nouvellement créé est dans l'état 'Nouveau'. Il n'est pas avancé de fonctionner dans cet état. L'exécution du code d'un thread dans le nouvel état n'a pas encore eu lieu. Il n'a pas encore couru.

État exécutable :

Les threads à l'état exécutable sont prêts à s'exécuter. Un thread dans cet état peut être prêt à s'exécuter à tout moment ou peut déjà être en cours d'exécution. Le planificateur de threads affine la responsabilité d'allouer du temps à l'exécution du thread. Chaque thread individuel se voit attribuer un temps spécifique dans un programme multi-thread. Chaque thread individuel s'exécute pendant une courte durée, puis rencontre une pause. Le processeur est ensuite cédé à un autre thread pour permettre aux autres threads de s'exécuter. À ce stade, tous les threads prêts à s'exécuter qui attendent le processeur et les threads en cours d'exécution se trouvent dans un état exécutable.

Consultez nos cours de technologie gratuits pour vous démarquer de la concurrence.

Explorez nos cours populaires de génie logiciel

État en attente/bloqué :

Un thread est dans l'un des états mentionnés ci-dessous lorsqu'il ne fonctionne temporairement pas.

• En attendant
• Bloqué

Un thread attendant la fin des E/S est dans un état bloqué. La fonction du planificateur de threads est de programmer l'exécution d'un thread bloqué ou en attente en le réactivant. Tout thread dans cet état n'est pas autorisé à poursuivre l'exécution jusqu'à ce qu'il soit transformé en un état exécutable. Les threads en état de blocage ou d'attente n'utilisent aucun cycle CPU.

Un thread est forcé d'être bloqué lorsqu'il tente d'accéder à la section protégée d'un code qui est actuellement protégée par un autre thread. Le planificateur transforme l'un des threads en attente d'une section protégée en un état exécutable lorsque la section est déverrouillée pour tous les threads. D'autre part, un thread existe dans un état d'attente pendant qu'il attend l'autre thread dans une condition particulière. Les threads à l'état d'attente sont poussés vers un état exécutable une fois que la condition spécifiée pour l'attente est satisfaite. Si un thread en cours d'exécution est déplacé vers un état d'attente/bloqué, le planificateur de threads planifie l'exécution d'un autre thread de la séquence exécutable.

Attente chronométrée :

Lorsqu'une méthode est invoquée avec un argument de délai d'attente, le thread existe dans un état d'attente temporisé. Un thread reste dans cet état jusqu'à la fin du délai d'attente spécifié ou jusqu'à la réception d'une notification. Par exemple, un thread passe à un état d'attente temporisé s'il invoque une attente ou une mise en veille conditionnelle.

État terminé :

L'arrêt des threads a lieu pour l'une des raisons suivantes.

• La sortie normale du thread à la fin de l'exécution des segments de code dans le thread.
• Occurrence de tout événement erroné rare tel qu'une exception non gérée et un défaut de segmentation.

Un thread dans un état terminé ne consomme aucun cycle CPU.

Apprenez des cours de développement de logiciels en ligne dans les meilleures universités du monde. Gagnez des programmes Executive PG, des programmes de certificat avancés ou des programmes de maîtrise pour accélérer votre carrière.

Compétences en développement de logiciels à la demande

Implémentation des états de thread en Java :

Pour accomplir l'état actuel d'un thread en Java, nous utilisons la méthode Thread.getState(). Java propose également la classe java.lang.Thread.State dans laquelle les constantes ENUM pour l'état d'un thread sont définies. Les détails sont résumés dans le tableau ci-dessous.

Le thread repose dans un état NEW lorsqu'il vient d'être créé. Lorsque la méthode .start () est invoquée sur un thread, elle est déplacée vers un état Runnable par le planificateur de thread. Lorsque la méthode join() est invoquée sur une instance de thread, le thread qui exécute actuellement l'instruction de code attendra que ce thread se termine. Ainsi, avant l'impression de la déclaration finale sur la console, la fonction join() est invoquée sur le thread 2 par le programme et maintient le thread1 en attente jusqu'à ce que le thread2 termine son exécution et passe à l'état terminé. Puisque thread1 attend la fin de l'exécution de thread2, il est mis dans l'état WAITING.

Lisez nos articles populaires liés au développement de logiciels

Avantages et limites de l'utilisation des threads dans les programmes Java :

L'utilisation de threads dans les programmes Java présente les avantages suivants.

• Réduction du temps de développement du code
• Coûts d'entretien réduits
• Amélioration des performances des applications complexes
• Booster la réactivité des interfaces utilisateurs
• Paralléliser les tâches
• Les threads sont utilisés dans les applications serveur pour améliorer le débit élevé et l'utilisation des ressources.
• Si toutes les ressources de calcul du processeur ne peuvent pas être utilisées par un thread, l'exécution d'un autre thread les maintiendra engagées.
• Si le même ensemble de données est exploité par plusieurs threads, leur cache peut être partagé. Cela conduit à une meilleure utilisation du cache ou à l'harmonisation de ses valeurs.

L'utilisation de threads dans les programmes Java présente plusieurs inconvénients. Certains d'entre eux sont énumérés ci-dessous.

• Lors du partage de caches, de tampons de recherche de traduction (TLB) ou de toute autre ressource matérielle, plusieurs threads peuvent interférer les uns avec les autres.
• Même lorsqu'un seul thread fonctionne, le temps d'exécution d'un thread ne peut pas être amélioré. Cependant, la dégradation du temps d'exécution est autorisée. Cela peut être dû aux étages de pipeline supplémentaires et/ou aux fréquences plus lentes qui sont nécessaires pour la prise en charge du matériel de commutation de thread.
• De nombreux changements sont nécessaires à la fois dans les systèmes d'exploitation et les programmes d'application par rapport au multitraitement car le support matériel est plus exposé au logiciel dans le multithreading.

Si vous souhaitez en savoir plus sur Java, le développement de logiciels full-stack, consultez le programme Executive PG de upGrad & IIIT-B en développement de logiciels - Spécialisation en développement Full Stack, conçu pour les professionnels en activité et offrant plus de 500 heures de formation rigoureuse. , 9+ projets et affectations, statut d'ancien de l'IIIT-B, projets de synthèse pratiques et aide à l'emploi avec les meilleures entreprises.

Préparez-vous à une carrière d'avenir

Postulez maintenant pour une maîtrise en génie logiciel