multithreading java tutorial with examples
Ce didacticiel explique tout sur le multithreading en Java, l'implémentation de la concurrence, le cycle de vie d'un thread, l'exemple de classe de thread, le thread utilisant l'interface exécutable:
La concurrence dans le monde informatique est la capacité d'un système (qu'il s'agisse d'une application, d'un ordinateur ou d'un langage de programmation) à exécuter plusieurs instances d'un programme ou d'une application en parallèle.
En exécutant des instances ou des programmes simultanément, nous garantissons un débit élevé et des performances plus élevées, car nous pouvons utiliser les ressources inexploitées telles que le matériel du système d'exploitation, etc. Par exemple, si un système dispose de plusieurs processeurs, l'application peut utiliser ces processeurs efficacement et augmenter le débit.
=> Visitez ici pour la série exclusive de didacticiels de formation Java.
Ce que vous apprendrez:
- Qu'est-ce que le multithreading en Java
- Qu'est-ce qu'un thread en Java
- Conclusion
Qu'est-ce que le multithreading en Java
En Java, les threads peuvent être considérés comme l'épine dorsale de la concurrence. Un thread est une unité exécutable et légère qui accède aux ressources partagées ainsi qu'à sa propre pile d'appels.
Une application Java est un processus et dans cette application, nous pouvons avoir plusieurs threads pour obtenir la concurrence.
Nous savons qu'une application exécutée sur le système peut avoir plusieurs instances et celles-ci sont généralement appelées applications multi-doc. Ces instances d'application sont appelées processus. Chacun de ces processus se voit attribuer une unité d'exécution appelée thread.
Selon le système d'exploitation et les exigences de l'application, le processus peut se voir attribuer un seul thread ou plusieurs threads. Lorsque le processus d'application se voit attribuer plusieurs threads, nous devons exécuter ces plusieurs threads simultanément.
' Cette technique d'exécution ou d'exécution de plusieurs threads simultanément ou simultanément est connue sous le nom de multithreading . '
Le multithreading signifie simplement que -nous avons plus d'un thread en cours d'exécution dans la même application.
Le langage de programmation Java a un support intégré pour le multithreading.
Le multithreading est illustré dans le diagramme ci-dessus. Comme indiqué, plusieurs threads s'exécutent simultanément dans une application.
Par exemple, une application de bureau fournissant des fonctionnalités telles que l'édition, l'impression, etc. est une application multithread. Dans cette application, comme l'impression est un processus d'arrière-plan, nous pouvons effectuer l'édition de documents et l'impression de documents simultanément en attribuant ces fonctions à deux fils différents.
Les threads des applications multithreads s'exécutent parallèlement les uns aux autres de manière concurrente. Ainsi, le multithreading fait également partie de la concurrence en Java. Notez que bien qu'il existe plusieurs threads, ils partagent la zone de mémoire, économisant ainsi sur la mémoire. De plus, les threads peuvent facilement changer de contexte en un rien de temps.
Le multithreading est principalement utile car il permet l'exécution simultanée de deux ou plusieurs parties d'une application. Cela permet à l'application d'utiliser le temps CPU à son maximum et le temps d'inactivité est réduit au minimum.
Voici quelques-uns des termes que nous devrions connaître en relation avec l'environnement multithreading car ils sont fréquemment utilisés.
Multitâche: En multitâche, plusieurs tâches sont exécutées en même temps.
Multithreading: Le multithreading, comme déjà mentionné, est un processus d'exécution de plusieurs threads simultanément.
quelle est la différence entre sql et sql server
Multitraitement: En multitraitement, plusieurs processus sont exécutés simultanément. Similaire au multitâche, mais ici plus d'un processeur est impliqué.
Traitement parallèle: Le traitement parallèle est une technique dans laquelle plusieurs processeurs fonctionnent simultanément dans un système informatique.
Après avoir discuté du multithreading, la question se pose de savoir pourquoi nous avons besoin du multithreading?
Avantages du multithreading
Le multithreading présente divers avantages qui contribuent à une programmation efficace.
Les points ci-dessous le rendront clair.
# 1) Utilisation efficace des systèmes à processeur unique
Lorsqu'il n'y a qu'un seul processeur dans le système, avec un seul thread, le temps processeur est gaspillé. Lorsque le thread est occupé à utiliser d'autres ressources telles que IO, le processeur est inactif. Nous pouvons améliorer cela et mieux utiliser le processeur en ayant des applications multithread.
En utilisant le multithreading, si un thread est fait avec CPU, alors l'autre thread peut l'utiliser. Avec plusieurs threads, le temps d'inactivité du processeur sera considérablement réduit.
# 2) Utilisation efficace de plusieurs systèmes CPU
Tout comme les processeurs uniques, même avec des systèmes ayant plusieurs processeurs, les applications multithreads sont capables d'utiliser efficacement plusieurs processeurs.
# 3) Expérience utilisateur améliorée en ce qui concerne la réactivité et l'équité
La réactivité du système s'améliore avec les applications multithread. Nous ne faisons pas l'expérience du «GUI suspendu» lorsque plusieurs threads accomplissent diverses tâches dans l'application et que les utilisateurs n'ont pas besoin d'attendre longtemps pour obtenir une réponse à leurs demandes.
De même, les utilisateurs sont correctement des services dans des systèmes multithread.
Comment implémenter la concurrence en Java
La première classe à l'aide de laquelle nous pouvons implémenter la concurrence en Java est java.lang.Thread classer. Cette classe Thread constitue la base de la concurrence en Java.
Nous avons aussi java.lang.Runnable interface qui peut être implémentée par une classe Java pour abstraire le comportement du thread. Pour le développement d'applications avancées, nous pouvons utiliser le java.util.concurrent package disponible depuis Java 1.5.
À l'avenir, nous discuterons en détail de la concurrence dans Java. Discutons et comprenons le concept de threads en Java dans ce didacticiel. Dans nos didacticiels suivants sur le multithreading, nous explorerons divers concepts de multithreading et de concurrence.
Qu'est-ce qu'un thread en Java
Un seul thread peut être défini comme l'unité de traitement la plus petite et la plus légère. En Java, les threads sont utilisés dans les programmes utilisant la classe «Thread».
Les threads Java sont de deux types:
# 1) Fil utilisateur: Le fil utilisateur est créé au premier démarrage de l'application. Ensuite, nous pouvons créer autant de threads d'utilisateurs et de démons.
# 2) Fil de démon: les threads démons sont principalement utilisés en arrière-plan et sont utilisés pour des tâches telles que le nettoyage de l'application, etc.
Les threads réduisent le coût de maintenance de l'application. Cela réduit également les frais généraux de l'application.
Un exemple de thread unique est illustré ci-dessous:
public class Main{ public static void main (String () args){ System.out.println('This is a thread'); } } Le programme ci-dessus affichera «Ceci est un thread» comme lorsque l'application démarre, un thread utilisateur est créé. Dans le programme ci-dessus, la fonction principale est le point de départ de l'application et crée un thread utilisateur.
Le cycle de vie d'un fil
Le diagramme suivant illustre le cycle de vie d'un thread en Java.
Comme le montre le diagramme ci-dessus, un thread en Java a les états suivants:
logiciel de pare-feu gratuit pour Windows 10
# 1) Nouveau: Au départ, le thread qui vient d'être créé à partir de la classe de thread a un état «nouvel». Il n'a pas encore commencé. Ce fil est également appelé «Fil né» .
# 2) Exécutable: Dans cet état, l'instance d'un thread est appelée à l'aide de la méthode 'début' .
# 3) En cours d'exécution: La méthode de démarrage de l'instance de thread est appelée et le thread commence l'exécution. C'est l'état en cours. Surtout le planificateur planifie et gère les threads.
# 4) Bloqué: Il existe plusieurs threads dans une application. Ces threads doivent en attendre un autre car leur exécution doit être synchronisée.
# 5) Terminé: Une fois le processus d'exécution du thread terminé, le thread se termine ou son exécution est arrêtée.
Ainsi, un thread est d'abord créé, puis planifié et plus tard, le planificateur exécute le thread. Alors que le thread en cours d'exécution peut être bloqué ou suspendu pour une autre activité. Ensuite, il est repris et pendant que le traitement se termine, le thread est exécuté.
Priorités des threads
Une priorité de thread décide comment un thread doit être traité par rapport aux autres threads d'une application. Une priorité de thread est un nombre entier.
Vous trouverez ci-dessous quelques points à retenir sur les priorités des threads:
- Les priorités des threads sont des nombres entiers.
- En utilisant la priorité des threads, nous pouvons décider quand nous devons passer d'un thread en cours d'exécution à un autre. C'est le processus de changement de contexte dans lequel nous changeons les contextes des threads.
- Chaque fois qu'un thread peut volontairement libérer son contrôle sur le processeur. Ensuite, le thread avec la priorité la plus élevée peut prendre le relais.
- De même, un thread de priorité plus élevée peut préempter tout autre thread avec une priorité inférieure.
- La classe Thread fournit une méthode setPriority () qui est utilisée pour définir la priorité du thread.
- Nous pouvons également utiliser les constantes MIN_PRIORITY, MAX_PRIORITY ou NORM_PRIORITY à la place des entiers.
Créer un fil
Nous pouvons créer un thread en utilisant l'une des méthodes suivantes:
- Extension de la classe Java «Thread».
- Mettre en œuvre «Runnable».
Extension de la classe «Thread» Java
La classe «Thread» contient les constructeurs et les méthodes qui nous permettent de créer et d’exécuter des opérations sur un objet thread. En interne, la classe Thread implémente l'interface Runnable et étend également la classe Object.
Le tableau suivant résume les différents constructeurs et méthodes d'une classe Thread ().
| Constructeur/ | Prototype | La description |
|---|---|---|
| dormir | public void sleep (longues millisecondes) | L'exécution du thread actuel est arrêtée pendant des millisecondes spécifiées. |
| Constructeur Thread () | Fil de discussion() | Constructeur par défaut pour créer un objet Thread. |
| Thread (nom de chaîne) | Constructeur pour créer un objet Thread avec le nom spécifié. | |
| Fil (Runnable r) | Créez une instance Thread avec un objet d'interface Runnable spécifié. | |
| Thread (Runnable r, nom de chaîne) | Créer une instance de Thread avec un objet d'interface Runnable spécifié et un nom donné | |
| courir | public void run () | La méthode Run exécute l'action pour un thread. Invoque le fil. |
| début | public void start () | Utilisé pour démarrer l'exécution du thread. En interne, la JVM appelle la méthode run () sur ce thread. |
| rejoindre | jointure publique void () | Attends que le fil meure |
| jointure vide publique (longues millisecondes) | Attendez les millisecondes spécifiées pour que le thread meure. | |
| getPriority | public int getPriority () | Renvoie la priorité du thread |
| définir la priorité | public int setPriority (priorité int) | Changer la priorité du thread en priorité spécifiée |
| getName | public String getName () | renvoie le nom du thread. |
| setName | public void setName (nom de la chaîne) | Définissez le nom du thread sur la chaîne spécifiée |
| currentThread | public Thread currentThread () | Renvoie la référence du thread actuellement actif |
| getId | public int getId () | Identifiant de fil de retour |
| getState () | public Thread.State getState () | Renvoie l'état actuel du thread |
| est vivant | public booléen isAlive () | Vérifiez si le thread est actif et renvoie true si oui. |
| rendement | public void yield () | Interrompt temporairement le thread actuel et autorise l'exécution d'autres threads. |
| isDaemon | public booléen isDaemon () | Vérifiez si le thread est un thread démon; retourne vrai si oui. |
| setDaemon | public void setDaemon (booléen) | Définissez le thread comme un thread démon si b = true; else défini comme fil utilisateur. |
| interrompre | public void interruption () | Interrompez le thread en cours. |
| est interrompu | public boolean isInterrupted () | Vérifiez si le fil est interrompu. |
| interrompu | public static boolean interrompu () | Vérifiez si le fil en cours a été interrompu. |
| dumpStack | DumpStack de vide statique () | Imprime une trace de pile du thread actuel dans le flux d'erreur standard. |
| suspendre | public void suspend () | Suspend tous les threads. (** la méthode est obsolète dans les dernières versions de Java) |
| CV | CV vide public () | Reprendre le thread suspendu. (** la méthode est obsolète dans les dernières versions de Java) |
| Arrêtez | arrêt public void () | Arrête le fil. (** la méthode est obsolète dans les dernières versions de Java) |
Nous développerons ces méthodes de thread dans notre prochain tutoriel sur le multithreading.
Démarrer un fil
La méthode start () utilisée pour démarrer le thread effectue les étapes suivantes:
- Démarre une nouvelle instance de thread avec un nouveau CallStack.
- L'état du thread passe de nouveau à exécutable.
- Quand c'est au tour du thread, il exécute la méthode run ().
Implémentation de l’interface ‘Runnable’
Une instance de thread peut également être créée à l'aide de l'interface Runnable. Pour créer une instance de thread, la classe dont les objets doivent être exécutés par un thread doit implémenter l'interface Runnable.
L'interface Runnable n'a qu'une seule méthode:
public void run () => this method is used to execute the thread. Exemple de classe de thread
Voyons maintenant le thread en Java en utilisant la classe thread.
//class inherited from 'Thread' class ThreadClassDemo extends Thread { private int number; //class constructor public ThreadClassDemo(int number) { this.number = number; } //run method => execution code for thread public void run() { int counter = 0; int numInt = 0; //prints the number till specified number is reached, starting from 10 do { numInt = (int) (counter + 10); System.out.println(this.getName() + ' prints ' + numInt); counter++; } while(numInt != number); System.out.println('** Correct! ' + this.getName() + 'printed ' + counter + ' times.**'); } } public class Main { public static void main(String () args) { System.out.println('Starting thread_1...'); //create a thread class instance Thread thread_1 = new ThreadClassDemo(15); //start the thread thread_1 thread_1.start(); try { //wait for thread_1 to die thread_1.join(); } catch (InterruptedException e) { System.out.println('Thread interrupted.'); } System.out.println('Starting thread_2...'); Thread thread_2 = new ThreadClassDemo(20); //start thread_2 thread_2.start(); System.out.println('main() is ending...'); } } Production
Thread Java à l'aide de l'interface exécutable
L'exemple suivant illustre l'utilisation de l'interface Runnable pour créer une instance de thread.
//class implements Runnable interface class RunnableDemo implements Runnable { private String message; //class constructor public RunnableDemo(String message) { this.message = message; } //run method public void run() { while(true) { System.out.println(message); } } } public class Main { public static void main(String () args) { //create first thread instance hello Runnable hello = new RunnableDemo('Hello, Greetings!!!'); Thread thread1 = new Thread(hello); thread1.setDaemon(true); //set this thread as daemon thread1.setName('hello'); System.out.println('Starting First thread...'); //start the thread thread1.start(); //create second thread instance bye Runnable bye = new RunnableDemo('Bye for now!!'); Thread thread2 = new Thread(bye); thread2.setPriority(Thread.MIN_PRIORITY); //set priority to min thread2.setDaemon(true); //set as daemon thread System.out.println('Starting goodbye thread...'); //start the thread thread2.start(); System.out.println('main() is ending...'); } }Production
Comment arrêter un thread en Java
Nous avons vu les exemples de fil ci-dessus. À partir de ces exemples, nous savons que lorsque la méthode run termine l'exécution, le thread s'arrête ou s'arrête également à cause de certaines exceptions.
Les versions antérieures de Java avaient une méthode stop () dans la classe Thread qui pouvait être utilisée pour arrêter directement le thread. Mais il est désormais obsolète pour des raisons de sécurité. Nous devons donc utiliser les autres méthodes pour arrêter le thread en cours d'exécution.
Il existe deux méthodes que nous pouvons utiliser pour arrêter le thread.
- Utilisation d'une variable booléenne volatile
- Utilisation des interruptions.
Dans cette section, nous aborderons ces deux méthodes pour arrêter un thread.
Utilisation d'une variable booléenne volatile
Dans cette méthode, nous maintenons une variable booléenne dite flag, pour arrêter le thread. Le thread s'exécute tant que la variable booléenne est définie sur true. Au moment où il devient faux, le thread est arrêté.
La spécialité de cette méthode est que nous déclarons la variable booléenne comme ' volatil ”Afin qu'il soit toujours lu à partir de la mémoire principale et que le programme ne puisse pas le mettre en cache dans le cache du CPU. De cette façon, il n'y aura aucune différence dans les valeurs définies et lues.
L'implémentation de l'arrêt d'un thread à l'aide d'une variable booléenne volatile est illustrée ci-dessous.
class StopThread extends Thread { private volatile boolean stop_flag = true; //initially set to true public void stopRunning() { stop_flag = false; //set stop_flag to false } @Override public void run() { while (stop_flag) { //keep checking value of stop_flag System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } //call stopRunning() method to stop the thread stop_thread.stopRunning(); } } Production
Noter: Ici, nous n'avons montré qu'une partie de la sortie. Le thread peut fonctionner pendant plusieurs minutes avant de s'arrêter. Afin que nous puissions obtenir différentes sorties sur différents systèmes.
Utilisation des interruptions
Ici, le thread est arrêté en utilisant la méthode interrupt () comme nous l'avons déjà discuté ci-dessus dans les méthodes de classe de thread. La méthode interrupt () définit l'état du thread comme interrompu. Cet état est transmis à la boucle while de la méthode run (). Nous pouvons obtenir le statut interrompu en utilisant la méthode interrompue ().
Le programme suivant montre l'utilisation de la méthode interrupt () pour arrêter le thread.
class StopThread extends Thread { @Override public void run() { while (!Thread.interrupted()) { //check for interrupted status System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //interrupt the thread stop_thread.interrupt(); } } Production
Questions fréquemment posées
Q # 1) Pourquoi utilisons-nous le multithreading en Java?
Répondre: Le multithreading permet l'exécution simultanée ou simultanée de deux ou plusieurs threads dans une application. L'exécution simultanée maximise le débit et utilise également le processeur à son maximum.
Q # 2) Qu'est-ce que le multithreading? Quels sont ses types?
Répondre: Le multithreading signifie l'exécution de plusieurs threads. Cette exécution peut être simultanée ou parallèle. Ainsi, le multithreading a deux types, à savoir simultané ou parallèle.
Q # 3) Qu'est-ce que le multithreading et le multitraitement?
Répondre: En multithreading, il existe plusieurs threads pour le même processus ou pour des processus différents et ces threads s'exécutent simultanément pour améliorer la vitesse de calcul d'un système. En multitraitement, un système possède plus de deux processeurs et plusieurs processus s'exécutent simultanément.
Q # 4) Quels sont les avantages du multithreading en Java?
Répondre: En utilisant le multithreading, nous pouvons exécuter différentes parties d'une application simultanément en utilisant des threads. Le multithreading augmente le débit du système. Le multithreading maximise également l'utilisation du processeur car différents threads utilisent en permanence le processeur.
Q # 5) Le multithreading est-il bon pour les jeux?
Répondre: Oui, en particulier pour les jeux modernes.
Conclusion
Il s'agit de l'introduction du multithreading. Nous avons discuté de la concurrence et du multi-threading en Java dans ce tutoriel. Nous avons discuté de la création d'un thread avec la classe Thread ainsi que de l'interface Runnable et avons fourni des exemples appropriés.
Nous avons également appris en détail les concepts d'un seul fil et sa création. Les concepts de thread, y compris le cycle de vie d'un thread, l'arrêt d'un thread, les types de thread, etc. ont été abordés dans ce didacticiel.
Nous avons également discuté du multithreading en détail et de la concurrence en Java. À la fin de ce tutoriel, le lecteur devrait être capable d'appréhender facilement les concepts de concurrence et de multithreading ainsi que les threads en Java.
=> Regardez la série de formation Java simple ici.
lecture recommandée
- Multithreading en C ++ avec des exemples
- Threads Java avec méthodes et cycle de vie
- Thread.Sleep () - Méthode Thread Sleep () en Java avec des exemples
- Tutoriel JAVA pour les débutants: plus de 100 tutoriels vidéo Java pratiques
- Tutoriel de réflexion Java avec des exemples
- Tutoriel sur la méthode Java String contains () avec des exemples
- Jagged Array In Java - Tutoriel avec des exemples
- Tutoriel de classe de scanner Java avec des exemples