Multithreading in Java | Expliqué
Cette rédaction présente un guide complet de la lecture multithre en Java et pour une compréhension profonde, il couvrira les concepts suivants:
- Qu'est-ce que le multithreading à Java
- Pourquoi le multithreading est important en Java
- Cycle de vie des fils à Java
- Méthodes d'accumulation Java pour le multithreading
- Mise en œuvre pratique du multithreading en Java
Alors, commençons!
Qu'est-ce que le multithreading
C'est un processus qui nous permet d'exécuter au moins deux threads en même temps et il est également appelé concurrence en Java. Java Multithreading maximise l'utilisation du processeur car il exécute chaque thread paralelly. De plus, il enregistre la mémoire car dans le multithreading, il n'est pas nécessaire d'allouer une mémoire séparée à plusieurs threads.
Pourquoi le multithreading est important en Java
Multithreading offre une large gamme de fonctionnalités et l'importance de Java Multithreading peut être évaluée à partir des fonctionnalités ci-dessous:
- Java Multithreading permet le partage de ressources, donc dans un processus, plusieurs ressources peuvent être partagées telles que le code, la mémoire, les fichiers, les données, etc.
- Les threads sont indépendants, donc les exceptions qui se sont produites dans un thread n'affecteraient pas les performances des autres.
- Multithreading in Java permet à un programme de s'exécuter même si un élément spécifique du programme est bloqué pour une raison quelconque ou exécutant une longue tâche / opération.
- Il fait gagner du temps car plusieurs tâches / opérations peuvent être effectuées simultanément.
Seules quelques fonctionnalités sont répertoriées ici, cependant, il y a beaucoup d'autres comme l'évolutivité, la rentabilité, etc. qui montrent la domination du multithreading.
Cycle de vie des fils à Java
Pour l'instant, nous avons appris ce qui est multithreading et pourquoi est-il si important en Java? Nous allons maintenant en apprendre davantage sur le cycle de vie du fil qui est composé de divers États comme indiqué ci-dessous:
Nouveau: Dans cet état, un thread est initié / créé à l'aide du "Fil de discussion" classe ou "Runnable" interface. Il reste dans cet état jusqu'à ce qu'un programme démarre / déclenche un fil.
Runnable: Dans cet état, l'instance du thread sera invoquée à l'aide d'une méthode intégrée start () et le thread reste à l'état exécutable jusqu'à ce qu'une tâche s'exécute.
En cours d'exécution: Dans cet état, un thread démarre l'exécution.
En attendant: Dans cette phase, le fil va à un état temporairement inactif, ce qui signifie qu'un thread dort, attend ou dans un état bloqué.
Terminé / mort: Un thread entre dans cet état lorsqu'une exception se produit ou si le thread termine son exécution / traitement.
Méthodes d'accumulation Java pour le multithreading
Il existe une liste de méthodes prédéfinies Java qui peuvent être utilisées dans les threads pour atteindre différentes fonctionnalités. Certaines méthodes fréquemment utilisées sont répertoriées dans le tableau ci-dessous:
| Nom de méthode | Description |
|---|---|
| commencer() | Il est utilisé pour démarrer l'exécution du thread. |
| courir() | Effectue une action spécifique pour un fil. |
| getName () | Renvoie le nom du fil. |
| rendement () | Arrête le thread actuel et permet aux autres d'exécuter. |
| setPriority (int newpriority) | Spécifie la priorité du fil. |
| getPriority () | Renvoie la priorité du thread. |
| Sommeil (int millisecondes) | Dorme le fil pour une période de temps spécifiée. |
| getID () | Renvoie l'identification du thread. |
Mise en œuvre pratique du multithreading en Java
Maintenant, il est temps de comprendre le concept de multithreading Java en utilisant la mise en œuvre pratique. Ainsi, nous allons considérer un exemple où nous effectuerons le multithreading et utiliserons certaines des méthodes intégrées susmentionnées.
Exemple
Dans cet exemple, nous effectuerons le multithreading en implémentant l'interface Runnable:
classe publique MultithreadingExample implémente Runnable@Passer outre
public void run ()
public static void main (String [] args)
Thread ThreadObj1 = nouveau thread ("Thread1");
Thread ThreadObj2 = nouveau thread ("Thread2");
threadobj1.commencer();
threadobj2.commencer();
Système.dehors.println ("Nom du premier thread:" + threadoBj1.getName ());
Système.dehors.println ("Nom du deuxième thread:" + threadoBj2.getName ());
Dans l'extrait de code ci-dessus, nous implémentons l'interface Java Runnable, et dans la classe, nous utilisons le @Passer outre annotation qui montre que le «MultithreadingExample» empose sur le courir() Méthode d'interface runnable. Ensuite, nous créons plusieurs threads et commençons l'exécution du thread à l'aide du commencer() méthode. Enfin, nous obtenons les noms du thread en utilisant le getName () Méthode et imprimez-les comme indiqué dans l'extrait ci-dessous:
Cela vérifie le fonctionnement des multi-threads en Java.
Dans l'exemple ci-dessus, nous effectuons le multithreading en implémentant Coulant interface. Cependant, nous pouvons également effectuer le multithreading en étendant un prédéfini Fil classe comme indiqué dans l'extrait suivant:
Classe publique MultithreadingExample étend ThreadEn étendant la classe de threads, vous pouvez profiter des fonctionnalités des méthodes Java prédéfinies.
Conclusion
Le multithreading permet une exécution simultanée de deux threads ou plus qui maximise l'utilisation du processeur, gagnent du temps, de la mémoire, etc. Le multithreading peut être effectué en étendant ou en implémentant la classe de threads ou l'interface exécutable respectivement. Diverses méthodes intégrées de classe de threads et d'interface exécutable peuvent être utilisées dans le multithreading pour effectuer différentes fonctionnalités telles que l'arrêt du thread actuel et permettre à d'autres threads d'exécuter, spécifiant la priorité aux threads, etc.
Cet article explique différents aspects du multithreading tels que ce qui est le multithreading, son importance, son cycle de vie, ses méthodes et sa mise en œuvre pratique.