Avant d'introduire le notion de fil , nous n'avons pas pu exécuter plus d'une tâche en parallèle. C'était un inconvénient, et pour supprimer cet inconvénient, Concept de fil a été présenté.
UN Fil est un processus très léger, ou nous pouvons dire la plus petite partie du processus qui permet à un programme de fonctionner plus efficacement en exécutant plusieurs tâches simultanément.
dfs contre bfs
Afin d'effectuer des tâches complexes en arrière-plan, nous avons utilisé le Concept de fil en Java . Toutes les tâches sont exécutées sans affecter le programme principal. Dans un programme ou un processus, tous les threads ont leur propre chemin d’exécution distinct, de sorte que chaque thread d’un processus est indépendant.
Un autre avantage de l'utilisation fil est que si un thread obtient une exception ou une erreur au moment de son exécution, cela n'affecte pas l'exécution des autres threads. Tous les threads partagent une mémoire commune et ont leur propre pile, variables locales et compteur de programme. Lorsque plusieurs threads sont exécutés en parallèle en même temps, ce processus est appelé Multithreading .
De manière simple, un Thread est un :
- Fonctionnalité grâce à laquelle nous pouvons effectuer plusieurs activités au sein d’un seul processus.
- Processus léger.
- Série de déclarations exécutées.
- Séquence imbriquée d’appels de méthode.
Modèle de fil
Tout comme un processus, un thread existe dans plusieurs états. Ces états sont les suivants :
1) Nouveau (Prêt à fonctionner)
Un fil est dans Nouveau quand il obtient du temps CPU.
2) Courir
Un fil est dans une course à pied indiquer quand il est en cours d’exécution.
3) Suspendu
Un fil est dans le Suspendu indiquer quand il est temporairement inactif ou en cours d’exécution.
4) Bloqué
Un fil est dans le Bloqué indiquer quand il attend des ressources.
5) Terminé
Un thread arrive dans cet état lorsqu'à un moment donné, il arrête immédiatement son exécution.
Création d'un fil de discussion
Un fil de discussion est créé soit en « créant ou en implémentant » le Interface exécutable ou en prolongeant le Classe de fil de discussion . Ce sont les deux seules manières par lesquelles nous pouvons créer un fil.
Examinons en détail ces deux manières de créer un fil :
nbsp
Classe de fil de discussion
UN Classe de fil de discussion possède plusieurs méthodes et constructeurs qui nous permettent d'effectuer diverses opérations sur un thread. La classe Thread étend la Objet classe. Le Objet la classe implémente le Exécutable interface. La classe thread possède les constructeurs suivants qui sont utilisés pour effectuer diverses opérations.
Interface exécutable (méthode run())
L'interface Runnable doit être implémentée par la classe dont les instances sont destinées à être exécutées par un thread. L'interface exécutable nous donne le courir() méthode pour effectuer une action pour le thread.
Méthode start()
La méthode est utilisée pour démarrer un fil de discussion que nous venons de créer. Il démarre un nouveau fil de discussion avec une nouvelle pile d'appels. Après avoir exécuté le commencer() , le thread change l'état de New à Runnable. Il exécute le méthode exécuter() lorsque le thread obtient le bon moment pour l'exécuter.
Prenons un exemple pour comprendre comment nous pouvons créer un Java thread en étendant la classe Thread :
ThreadExample1.java
// Implementing runnable interface by extending Thread class public class ThreadExample1 extends Thread { // run() method to perform action for thread. public void run() { int a= 10; int b=12; int result = a+b; System.out.println('Thread started running..'); System.out.println('Sum of two numbers is: '+ result); } public static void main( String args[] ) { // Creating instance of the class extend Thread class ThreadExample1 t1 = new ThreadExample1(); //calling start method to execute the run() method of the Thread class t1.start(); } } Sortir:
Créer un thread en implémentant l'interface exécutable
En Java, nous pouvons également créer un thread en implémentant l'interface exécutable. L'interface exécutable nous fournit à la fois la méthode run() et la méthode start().
Prenons un exemple pour comprendre comment nous pouvons créer, démarrer et exécuter le thread à l'aide de l'interface exécutable.
jeu de hachage Java
ThreadExample2.java
class NewThread implements Runnable { String name; Thread thread; NewThread (String name){ this.name = name; thread = new Thread(this, name); System.out.println( 'A New thread: ' + thread+ 'is created
' ); thread.start(); } public void run() { try { for(int j = 5; j > 0; j--) { System.out.println(name + ': ' + j); Thread.sleep(1000); } }catch (InterruptedException e) { System.out.println(name + ' thread Interrupted'); } System.out.println(name + ' thread exiting.'); } } class ThreadExample2 { public static void main(String args[]) { new NewThread('1st'); new NewThread('2nd'); new NewThread('3rd'); try { Thread.sleep(8000); } catch (InterruptedException excetion) { System.out.println('Inturruption occurs in Main Thread'); } System.out.println('We are exiting from Main Thread'); } } Sortir:
Dans l'exemple ci-dessus, nous effectuons le multithreading en implémentant l'interface exécutable. Pour en savoir plus sur le multithreading, Cliquez ici .