Explication du multithreading en Java [avec exemples]

Threads en Java

Les threads en Java aident au fonctionnement efficace d'un programme. Les deux unités basiques d'exécution du formulaire sont le processus et les threads. Un processus peut être une application, un programme ou un environnement d'exécution autonome.

Alors que les threads partagent une ressource avec celle du processus et existent avec lui. Au moins un thread est présent dans chaque application Java appelé le thread principal. Plusieurs threads peuvent être créés à partir du thread principal. En savoir plus sur la création d'un thread en Java.

Avantages de Java Thread

• Moins de temps et de ressources sont nécessaires pour créer un thread par rapport aux processus. Par conséquent, les threads sont également appelés processus légers.
• Les données et le code du processus parent sont partagés par les threads.
• L'intercommunication entre les threads est facile par rapport à l'intercommunication dans un processus.
• Les threads en Java peuvent être créés via l'implémentation de java.lang. Interface exécutable.

Fil unique

Plusieurs unités de traitement sont présentes dans un programme dont la plus petite est appelée thread unique. Grâce à l'utilisation de la "classe de thread", Java applique les threads. Deux types de fil existent; le thread démon et le thread utilisateur.

Lorsque l'application doit être nettoyée, l'utilisation du thread démon se produit. Il s'exécute en arrière-plan d'une application. Tandis que les threads utilisateur sont créés au démarrage de l'application.

Avantages du fil unique :

• La surcharge de l'application est réduite car l'exécution d'un seul thread se produit dans un système.
• Le coût de maintenance de l'application est réduit grâce à l'utilisation de threads uniques.

Multitâche en Java

Le multitâche fait référence au processus d'exécution de plusieurs tâches par le CPU en une seule fois. Parfois, la commutation de CPU peut être effectuée entre les tâches par l'utilisateur pour collaborer avec chaque programme ensemble. Une mémoire et des ressources séparées sont allouées aux processus en multitâche. De deux manières, le multitâche peut être réalisé.

1. Multitraitement (multitâche basé sur des processus)

• Une zone mémoire distincte est allouée pour chaque processus. Il y a donc une adresse pour chaque processus en mémoire.
• Les processus sont lourds.
• Il y a un coût de communication élevé entre les processus.
• Un certain temps est nécessaire pour basculer entre les processus. Ceci est nécessaire pour mettre à jour les listes, les cartes mémoire, etc.

2. Multithreading (multitâche basé sur les threads)

• La même adresse est partagée entre les threads.
• Les fils sont légers.
• Le coût de communication entre les threads est faible.

Qu'est-ce que le multithreading ?

Lorsque deux ou plusieurs threads s'exécutent simultanément dans un programme, le mécanisme est appelé multithreading. Un seul processus crée de nombreux threads augmentant la puissance de calcul. Deux ou plusieurs parties d'un programme sont exécutées de manière à optimiser l'utilisation de la CPU.

Les threads sont appelés les parties individuelles du programme. Les processus d'une application peuvent contenir plusieurs threads ou des threads uniques.
Plusieurs threads d'une application sont autorisés par la machine virtuelle Java. Chaque thread a sa propre priorité. Par conséquent, la préférence d'exécution est donnée aux threads ayant une priorité plus élevée que ceux ayant une priorité inférieure.

Pour réaliser le multitâche, le processus de multithreading et de multitraitement est utilisé. Parce qu'une zone de mémoire partagée est utilisée dans le multithreading, elle est principalement utilisée sur le multitraitement. La mémoire est sauvegardée car aucune allocation supplémentaire de mémoire n'est requise. De plus, le temps pris est inférieur au multitraitement car le changement de contexte se produit entre les threads.

Dans l'animation, les jeux, le multithreading Java est utilisé. Cliquez sur si vous souhaitez en savoir plus sur l'architecture et les composants Java.

Deux mécanismes peuvent être utilisés pour créer des threads.

1. Extension de classe de thread

2. Implémentation de l'interface exécutable

Classe de thread vs interface exécutable

• L'extension de la "classe Thread" ne peut pas étendre d'autres classes car les héritages multiples ne sont pas pris en charge en Java. Mais avec l'implémentation de l'interface « Runnable », d'autres classes de base peuvent être étendues à partir de la classe.
• La fonctionnalité de base d'un thread peut être étendue en étendant la classe Thread car des méthodes intégrées sont fournies telles que interrupt(), yield(), etc.
• Un objet que plusieurs threads peuvent partager sera fourni lorsque runnable est utilisé.

Classe de thread Java

La programmation de threads en Java est réalisée via la classe thread. Les constructeurs sont fournis par la classe de thread et les méthodes pour effectuer des opérations de thread. Une classe thread implémente une interface exécutable et étend la classe Object.

Voici quelques méthodes de thread couramment utilisées :

1. start() : l'exécution du thread est lancée par cette méthode. La méthode run() est appelée par la JVM.
2. sleep(int milliseconds) : l'exécution du thread est interrompue pendant les millisecondes fournies lorsque le processus de thread est mis en veille via cette méthode. Après la pause, l'exécution du thread recommence. Les threads peuvent être synchronisés via cette méthode.
3. getName() : le nom du thread est renvoyé via cette méthode.
4. setPriority(int nouvelle priorité) : la priorité du thread est modifiée via cette méthode.
5. yield (): Le thread en cours est amené à s'arrêter avec l'exécution des autres threads par cette méthode.
6. run() : la méthode permet de démarrer une action dans le thread.
7. getPriority() : la priorité du thread est renvoyée via l'utilisation de cette méthode.
8. setName() : le nom du thread est modifié via cette méthode.
9. getId() : l'identifiant du thread est renvoyé via cette méthode.
10. suspend() : le thread est suspendu via cette méthode.

Cycle de vie des threads

Le cycle de vie des threads comporte différentes étapes, répertoriées ci-dessous :

1. Nouveau : "Thread class" est utilisé pour créer un thread à cette étape. Tant que le thread n'est pas lancé, le programme reste à ce stade. La méthode est aussi appelée le thread né.
2. Exécutable : la méthode start appelle l'instance de thread à ce stade du cycle de vie du thread. L'ordonnanceur se voit remettre le contrôle du thread pour terminer l'exécution. Que le thread soit exécuté ou non dépend du planificateur.
3. Running : Une fois l'exécution du thread lancée, l'étape passe à l'étape « running ». Un thread est sélectionné par le planificateur dans le pool de threads et démarre l'exécution de l'application.
4. Attente : Comme son nom l'indique, dans cette phase du cycle de vie, le thread attend. La synchronisation des threads est essentielle en raison de l'exécution de plusieurs threads dans une application. Par conséquent, il est nécessaire qu'un thread attende jusqu'à ce que l'exécution de l'autre thread soit terminée. Par conséquent, l'étape du cycle de vie est également connue sous le nom d'étape d'attente.
5. Mort : L'étape où se produit la fin du fil est appelée étape « morte ». Une fois que le thread est transféré de l'exécution à la fin du traitement, il se termine et se trouve donc dans "l'état mort"

Synchronisation des threads en Java

Un comportement asynchrone se produit dans un programme en cas de multithreading. Si des données sont censées être écrites via un thread et que la lecture des données est effectuée simultanément par un autre thread, une incohérence peut être créée dans l'application.

Les ressources partagées entre les threads doivent être accessibles par d'autres threads. Par conséquent, dans de tels cas, l'approche de la synchronisation est abordée. Des méthodes synchronisées sont disponibles en Java pour obtenir un comportement de synchronisation.

Lorsqu'un thread atteint le bloc synchronisé, puis une fois qu'il l'atteint, la méthode ne peut plus être appelée par d'autres threads sur le même objet. Jusqu'à ce que le thread ait fini d'exécuter le bloc et en sorte, les autres threads doivent s'arrêter et attendre.

Apprenez des cours 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.

Avantages du multithreading

• Plusieurs opérations peuvent être effectuées en même temps. Avec les threads indépendants en cours d'exécution, l'utilisateur n'est pas bloqué.
• Le temps est économisé car plusieurs opérations s'exécutent ensemble.
• Un thread ne peut pas être affecté par un autre thread car ils sont indépendants. L'occurrence d'une exception dans un thread n'affecte pas l'exécution des autres threads.

Exemple de multithreading

Un exemple de programme multithreading en Java a été montré ci-dessous :

La source

Figure 1 : Un extrait de l'exemple de code multithreading

L'explication du code

Ligne 3 : La classe « GuruThread1 » implémente runnable.

Ligne 8 : Elle affiche la méthode principale de la classe.

Ligne 9 : La classe de thread est instanciée et une instance "guruThread1" est créée et un thread est créé.

Ligne 10 : La « classe Thread » est instanciée et une instance « guruThread2 » et un thread sont créés.

Ligne 11 : Le thread nommé guruThread1 est démarré.

Ligne 12 : Le thread nommé guruThread2 est démarré.

Ligne 13 : Le texte « Les noms des threads suivent : » est affiché.

Ligne 14 : La méthode getName() est utilisée pour obtenir le nom du thread1.

Ligne 15 : La méthode getName() est utilisée pour obtenir le nom du thread2.

L'exécution du code ci-dessus donne le résultat suivant :

La source

Figure : Une capture d'écran de la sortie générée à partir du programme multithreading en Java (tiré de

Conclusion

L'article discutait du concept de multithreading en Java avec un exemple de programme multithreading en Java. Votre apprentissage ne s'arrête pas là et s'entend avec tous les autres concepts de base de Java.

Si vous souhaitez maîtriser vos compétences en programmation à un prix abordable et vous préparer à l'industrie, vous pouvez consulter le cours proposé par upGrad "Master of Science in Computer Science". Il s'adresse à tous les professionnels de niveau intermédiaire dans la tranche d'âge de 21 à 45 ans. Le cours est certifié par l'Université John Moores de Liverpool et conçu avec plus de 500 heures d'apprentissage, 309 projets et missions pour tirer le meilleur parti de vous. Si vous avez des questions, envoyez-nous un message, notre équipe vous contactera.

Décrochez le job de vos rêves

Postulez pour le programme Executive PG en développement de logiciels de l'IIIT-B