Multithreading en Java - Apprendre avec des exemples

Java est un langage de programmation qui prend en charge les programmes multithreads. Les programmes multithreads accueillent deux ou plusieurs parties (threads) qui s'exécutent simultanément, gérant différentes tâches, permettant une utilisation optimale du processeur. Le multi-threading est une extension du multi-tâches. Le multitâche peut être défini comme une fonctionnalité dans laquelle plusieurs processus partagent une ressource de traitement commune, telle qu'une unité centrale de traitement.

Le multithreading étend le concept de multitâche à diverses applications où des opérations définies peuvent être décomposées en threads individuels plus petits.

Chacun de ces threads s'exécute simultanément et indépendamment avec différents chemins d'exécution, de sorte qu'une exception dans un thread n'affecte pas les performances des autres.

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.

Qu'est-ce que le multithreading en Java ?

Le multithreading en Java est l'endroit où plusieurs threads sont exécutés simultanément pour maximiser le temps CPU.

Cycle de vie d'un thread

Les threads ont différentes étapes dans leur cycle de vie. Ils sont les suivants :

• Nouveau : le thread commence son cycle de vie en tant que nouveau thread. Il reste dans cette phase de nouveau-né jusqu'à ce qu'un programme exécute le thread.
• Exécutable : un thread né entre dans l'étape exécutable lorsqu'un programme le lance. Le thread commence à exécuter sa tâche à ce stade.
• Attente : Il s'agit d'une étape de transition où un thread attend qu'un autre thread termine sa tâche. Un thread dans la phase d'attente passe à une phase exécutable après avoir reçu un signal d'autres threads.
• Attente temporisée : il s'agit d'une étape dans laquelle un thread exécutable peut entrer pendant un intervalle de temps spécifique. Les threads de cette étape reviennent à l'étape exécutable à la fin de l'intervalle de temps spécifique.
• Mort : Il s'agit de la dernière étape du cycle de vie d'un thread. Un thread entre dans cette étape après avoir terminé sa tâche.

Avantages du multithreading en Java

• Comme les threads en Java sont indépendants, le multithreading Java ne bloque pas les utilisateurs et ils peuvent effectuer de nombreuses opérations simultanément.
• Comme le multithreading en Java permet plusieurs opérations, il est efficace et rapide.
• Le programme peut fonctionner en continu même si une partie de celui-ci est interceptée.
• Il améliore les performances par rapport aux programmes parallèles conventionnels qui utilisent plusieurs processus.
• Création de programmes efficaces qui utilisent le temps CPU au maximum.
• Améliore considérablement le temps de réponse des applications complexes.
• Nécessite moins de ressources par rapport aux programmes parallèles traditionnels.

Ordre de priorité des threads

Le système d'exploitation détermine le calendrier d'exécution du thread en fonction de la priorité du thread. La priorité d'un thread est déterminée en fonction de la valeur de sa constante.

• La constante 1 obtient la priorité minimale ( MIN_PRIORITY)
• La constante 5 obtient la priorité normale ( NORM_PRIORITY)
• La constante 10 obtient la priorité maximale (MAX_PRIORITY)

Cours et articles populaires sur le génie logiciel

Comment créer un thread en Java ?

Les threads peuvent être créés en Java de deux manières :

1. Extension de la classe de thread
2. Implémentation d'une interface exécutable

Création d'un thread en étendant la classe Thread

Quelques méthodes de classe thread et leurs fonctions sont données ci-dessous.

• getName() : Pour obtenir le nom du thread
• getPriority() : pour obtenir la priorité du thread
• is Alive() : pour savoir si un thread est en cours d'exécution
• join() : attend la fin d'un thread
• run() : Point d'entrée du thread
• sleep () : pour suspendre un thread pendant une fenêtre de temps spécifique.
• start() : Pour activer un thread via sa méthode run().

Étape 1 : Remplacez la méthode run() donnée dans la classe thread. Cela agit comme le point d'entrée du thread, et toute la logique du programme doit être enfermée dans 4this.

La syntaxe de la méthode run() est la suivante :

course vide publique ( )

Étape 2 : Initier l'objet thread par la méthode start() dont la syntaxe est un void start() .

Voici des exemples de programme multithreading en Java :

Exemple 1:

la classe MultithreadingDemo étend Thread{

public void run(){

System.out.println("Mon thread est en cours d'exécution.");

}

public static void main(String args[]){

MultithreadingDemo obj=new MultithreadingDemo();

obj.start();

}

}

La sortie du programme ci-dessus sera :

Mon fil est en cours d'exécution.

Exemple 2 :

la classe Count étend le thread

{

Compter()

{

super("mon fil s'étend");

System.out.println("mon fil est créé" + ceci);

début();

}

public void run()

{

essayer

{

pour (int i=0 ;i<10;i++)

{

System.out.println("Imprimer le compte" + i);

Thread.sleep(1000);

}

}

catch(InterruptedException e)

{

System.out.println("mon fil a été interrompu");

}

System.out.println("Mon fil est terminé" );

}

}

classe ExtendingExample

{

public static void main(String args[])

{

Compter cnt = nouveau Compter();

essayer

{

tandis que (cnt.isAlive())

{

System.out.println("Le thread principal sera vivant jusqu'à ce que le thread enfant vive");

Thread.sleep(1500);

}

}

catch(InterruptedException e)

{

System.out.println("Le thread principal a été interrompu");

}

System.out.println("L'exécution du thread principal est terminée" );

}

}

La sortie du programme ci-dessus sera

mon fil est crééThread[mon fil exécutable,5,main]

Le thread principal sera vivant jusqu'à ce que le thread enfant vive

Impression du compte 0

Impression du décompte 1

Le thread principal sera vivant jusqu'à ce que le thread enfant vive

Impression du décompte 2

Le thread principal sera vivant jusqu'à ce que le thread enfant vive

Impression du décompte 3

Impression du décompte 4

Le thread principal sera vivant jusqu'à ce que le thread enfant vive

Impression du décompte 5

Le thread principal sera vivant jusqu'à ce que le thread enfant vive

Impression du décompte 6

Impression du décompte 7

Le thread principal sera vivant jusqu'à ce que le thread enfant vive

Impression du décompte 8

Le thread principal sera vivant jusqu'à ce que le thread enfant vive

Impression du décompte 9

mon fil est terminé

L'exécution du thread principal est terminée

Création d'un thread en implémentant une interface exécutable

Il y a trois étapes importantes à suivre lors de l'utilisation de cette méthode.

Étape 1 : Une méthode run() doit être implémentée par une interface exécutable. Cette méthode run() sert de point d'entrée pour le thread et doit contenir toute la logique du programme.

La syntaxe de la méthode run() est

public void run( )

Étape 2 : Un objet thread doit être activé à l'aide du constructeur indiqué ci-dessous.

Thread(Runnable threadObj, String threadName);

Ici, threadObj agit comme la classe qui implémente l'interface exécutable, et le nom du thread est le nom donné au nouveau thread.

Étape 3 : Après avoir créé l'objet thread, il peut être lancé par la méthode start() qui exécute la méthode run().

La syntaxe de la méthode start() est la suivante.

void start();

Un exemple de création d'un thread en implémentant une interface exécutable peut être trouvé ici .

Pour en savoir plus sur le multithreading Java et le développement de logiciels, nous vous recommandons de vous inscrire au programme d'études supérieures en développement de logiciels proposé par IIIT Bangalore en association avec upGrad.

Le programme Executive PG en développement de logiciels est un programme en ligne de 13 mois conçu pour aider les professionnels en activité à faire un pas de géant dans leur carrière grâce à des études de cas et des projets pertinents pour l'industrie. Le programme comprend également plus de dix sessions en direct d'experts de l'industrie pour aider les candidats à mieux apprendre.

Le programme comprend des projets de l'industrie pour aider les candidats à acquérir une expérience pratique et une exposition adéquate à l'industrie pour rendre leur apprentissage pertinent et pratique. L'achèvement du programme récompensera les candidats avec la très convoitée certification IIIT B et le statut d'ancien élève.

Le programme est livré avec un support de placement à 360 degrés d'upGrad qui a eu un impact sur plus de 40 000 apprenants rémunérés de tous les coins du monde pour rendre les choses encore meilleures. upGrad a une base d'apprenants de plus de 85 pays offrant une opportunité inestimable d'avoir un réseau mondial de pairs pour les candidats.