Threads de création java (interface runnable et classe de thread)
Dans la plupart des cas, un thread est créé en instanciant un objet de thread. Java définit deux façons:
Ce qui suit décrit chaque méthode tour à tour.
Implémentation de l'interface Runnable
La façon la plus simple de créer un thread est de créer une classe qui implémente l'interface Runnable. Runnable résume une unité d'exécution de code. Vous pouvez créer des threads pour chaque objet en implémentant l'interface Runnable. Pour implémenter l'interface Runnable, une classe doit uniquement implémenter une méthode simple de run (), qui est déclarée comme suit:
public void run ()
Dans run (), vous pouvez définir le code pour créer de nouveaux threads. Il est crucial de comprendre ce qui suit: La méthode run () peut appeler d'autres méthodes, se référer à d'autres classes et déclarer des variables comme le thread principal. La seule différence est que Run () établit une autre entrée d'exécution de threads simultanée dans le programme. Lorsque Run () revient, le fil se termine.
Après avoir créé une classe qui implémente l'interface Runnable, vous devez instancier un objet de la classe de threads à l'intérieur de la classe. La classe de thread définit plusieurs constructeurs. Ce que nous utiliserons est le suivant:
Thread (filetage Runnable, Thread ThreadName)
Dans ce constructeur, ThreadOB est une instance qui implémente la classe d'interface Runnable. Cela définit le point de départ de l'exécution du thread. Le nom du nouveau thread est défini par ThreadName.
Une fois un nouveau thread créé, il ne s'exécute pas tant que sa méthode start () est appelée, qui est définie dans la classe de threads. Essentiellement, start () exécute un appel à exécuter (). La méthode start () est déclarée comme suit:
void start ()
L'exemple suivant est de créer un nouveau thread et de le démarrer en cours d'exécution:
// Créer un deuxième thread.class newthread implémente Runnable {Thread T; NewThread () {// Créer un nouveau thread T = New Thread (this, "Demo Thread"); : "+ t); t.start (); // démarrer le thread} // c'est le point d'entrée du deuxième thread. public void run () {try {for (int i = 5; i> 0; i - -) {System.out.println ("Child Thread:" + i); Out .println ("Exécution du thread de l'enfant.");}} class ThreadDemo {public static void main (String args []) {newthThread (); 0; )); Dans le constructeur NewThread, le nouvel objet Thread est créé par l'instruction suivante:
t = nouveau thread (this, "Demo Thread");
Cela indique que dans cet objet, vous souhaitez que le nouveau thread appelle la méthode run (). Ensuite, start () est appelé et l'exécution du thread est démarrée avec la méthode run (). Cela fait démarrer la boucle du fil d'enfant pour démarrer. Après avoir appelé start (), le constructeur newthread revient sur main (). Lorsque le fil principal est restauré, il atteint la boucle pour. Les deux fils continuent de fonctionner, partageant le CPU jusqu'à la fin de leur boucle. La sortie de ce programme est la suivante:
Thread de l'enfant: Thread [Thread de démonstration, 5, Main] Filetage principal: 5child Thread: 5child Thread: 4Main Thread: 4Child Thread: 3Child Thread: 2Main Thread: 3Child Thread: 1e Xiting Child Thread.Main Thread: 2Main Thread: 1main Threater Distinction .
Comme mentionné précédemment, dans un programme multi-thread, le fil principal doit généralement être le dernier thread qui se termine en cours d'exécution. En fait, pour certains anciens JVM, si le fil principal se termine avant le thread de l'enfant, le système d'exécution Java peut "accrocher". Le programme susmentionné garantit que le fil principal se termine à la fin, car le fil principal dort pendant 1000 millisecondes, tandis que le fil d'enfant ne représente que 500 millisecondes. Cela provoque la fin du fil de l'enfant avant la fin du fil principal. En bref, vous verrez une meilleure façon d'attendre que le fil se termine.
Fil prolongé
Une autre façon de créer un thread est de créer une nouvelle classe qui étend la classe de threads, puis crée une instance de cette classe. Lorsqu'une classe hérite du thread, il doit surcharger la méthode run (), qui est l'entrée du nouveau thread. Il doit également appeler la méthode start () pour démarrer la nouvelle exécution de thread. Ce qui suit consiste à réécrire le programme précédent avec la classe de threads étendue:
// Créer un deuxième thread en étendant ThreadClass NewThread étend Thread {newthread () {// Créer un nouveau thread, "Demo Thread"); (); ("Child Thread:" + I); ");}} class extendThread {public static void main (String args []) {new NewThread (); // Créer un nouveau thread try {for (int i = 5; i> 0; i--) {System. out :::::::::::::: .println ("Thread principal:" + i); Thread principal interrompu. ");} System.ou t.println (" Thread principal qui sort. ");}} Ce programme génère la même sortie que la version précédente. Le thread enfant est généré par l'objet Newthread instancié, qui est dérivé de la classe de threads. Notez l'appel à super () dans newthread. Cette méthode appelle le constructeur de threads du formulaire suivant:
Thread public (chaîne ThreadName)
Ici, ThreadName spécifie le nom du thread.
Choisissez la bonne méthode
À ce stade, vous vous demanderez certainement pourquoi Java a deux façons de créer des fils d'enfants, lesquels est le meilleur. Toutes les questions sont attribuées à un point. La classe de thread définit une variété de méthodes qui peuvent être surchargées par des classes dérivées. Pour toutes les méthodes, la seule chose qui doit être surchargée est la méthode run (). Ceci est bien sûr la même méthode requise pour implémenter l'interface Runnable. De nombreux programmeurs Java estiment que les classes ne doivent être étendues que lorsqu'ils sont renforcés ou modifiés. Par conséquent, si vous ne surchargez pas d'autres méthodes de thread, il est préférable d'implémenter uniquement l'interface Runnable. Bien sûr, c'est à vous de décider. Cependant, dans d'autres parties de ce chapitre, nous appliquons des classes qui implémentent l'interface Runnable pour créer des threads.