La classe Java Thread est également une classe d'objets, et ses instances sont héritées de java.lang.thread ou de sa sous-classe. Vous pouvez créer un fil en Java de la manière suivante. L'exécution du thread peut appeler la méthode start () du thread:
Tread Thread = new Thread ();
thread.start ();
Dans l'exemple ci-dessus, nous n'avons pas écrit de code en cours d'exécution pour le thread, donc le thread se termine après avoir appelé la méthode.
Il existe deux façons d'écrire du code exécuté lorsqu'un thread s'exécute: l'un est de créer une instance de la sous-classe de thread et de remplacer la méthode d'exécution, et la seconde consiste à implémenter l'interface Runnable lors de la création de la classe. Ensuite, nous expliquerons ces deux méthodes en détail:
Créer une sous-classe de fil
Créez une instance de la sous-classe de thread et remplacez la méthode d'exécution. La méthode d'exécution sera exécutée après avoir appelé la méthode start (). L'exemple de la sous-classe de thread ci-dessus peut être créé et exécuté de la manière suivante:
La classe publique Mythread étend Thread {public void run () {System.out.println ("Mythread Running"); }} Mythread mythread = new mythread (); myTread.start ();Une fois le thread au démarrage, la méthode de démarrage reviendra immédiatement et n'attendra pas que la méthode d'exécution soit exécutée avant le retour. C'est comme si la méthode d'exécution était exécutée sur un autre processeur. Lorsque la méthode d'exécution est exécutée, la chaîne Mythread en cours d'exécution sera imprimée.
Vous pouvez également créer une sous-classe anonyme de fil comme suit:
Thread Thread = new Thread () {public void run () {System.out.println ("Thread Running"); }}; thread.start ();Lorsque la méthode d'exécution du nouveau thread est exécutée, l'ordinateur imprimera la chaîne "Thread Running".
Implémentation de l'interface Runnable
La deuxième façon d'écrire du code d'exécution du thread est de créer une nouvelle instance de la classe qui implémente l'interface java.lang.runnable, et les méthodes de l'instance peuvent être appelées par le thread. Ce qui suit est un exemple:
classe publique Myrunnable implémente Runnable {public void run () {System.out.println ("Myrunnable Running"); }}Pour que les threads exécutent la méthode run (), il est nécessaire de passer l'objet d'instance de myrunnable dans le constructeur de la classe de threads. Les exemples sont les suivants:
Thread thread = nouveau thread (new Myrunnable ());
thread.start ();
Lorsque le thread s'exécute, il appellera la méthode d'exécution qui implémente l'interface Runnable. "Myrunnable Running" sera imprimé dans l'exemple ci-dessus.
De même, vous pouvez créer une classe anonyme qui implémente l'interface Runnable, comme indiqué ci-dessous:
Runnable myrunnable = new runnable () {public void run () {System.out.println ("runnable running"); }} Thread thread = new thread (myrunnable); thread.start ();Créer une sous-classe ou implémenter une interface exécutable?
Il n'y a pas de réponse définitive à laquelle de ces deux méthodes est meilleure, et ils peuvent répondre aux exigences. À mon avis, je préfère implémenter la méthode d'interface Runnable. Étant donné que le pool de threads peut gérer efficacement les threads qui implémentent l'interface Runnable, si le pool de threads est plein, les nouveaux threads mettront en file d'attente pour l'exécution jusqu'à ce que le pool de thread soit inactif. Et si le thread est implémenté en implémentant la sous-classe de thread, ce sera un peu plus compliqué.
Parfois, nous devons intégrer les deux façons d'implémenter l'interface Runnable et la sous-classe de thread en même temps. Par exemple, une instance qui implémente une sous-classe de thread peut exécuter plusieurs threads qui implémentent l'interface Runnable. Une application typique est le pool de threads.
Erreur commune: appelez la méthode run () au lieu de la méthode start ()
Une erreur courante commise en créant et en exécutant un thread est d'appeler la méthode Run () du thread au lieu de la méthode start (), comme indiqué ci-dessous:
Thread newthread = new thread (myrunnable ());
newthread.run (); // devrait être start ();
Au début, vous ne ressentez rien de mal, car la méthode run () est en effet appelée comme vous le souhaitez. Cependant, en fait, la méthode run () n'est pas exécutée par le nouveau thread qui vient de créer, mais est exécuté par le thread actuel qui a créé le nouveau thread. Autrement dit, il est exécuté par le thread qui exécute les deux lignes de code ci-dessus. Pour faire en sorte que le nouveau thread créé exécute la méthode run (), la méthode de démarrage du nouveau thread doit être appelée.
Nom de fil
Lors de la création d'un fil, vous pouvez donner un nom au fil. Il nous aide à distinguer différents fils. Par exemple: si plusieurs threads sont écrits sur System.out, nous pouvons facilement savoir quel thread sort via le nom de thread. Les exemples sont les suivants:
Myrunnable runnable = new myrunnable (); thread thread = new thread (runnable, "new thread"); thread.start (); system.out.println (thread.getName ());
Il convient de noter que parce que MyRunnable n'est pas une sous-classe de fil, la classe myrunnable n'a pas de méthode getName (). Vous pouvez obtenir une référence au thread actuel de la manière suivante:
Thread.currentThread ();
String threadName = Thread.currentThread (). GetName ();
Exemple de code de thread:
Voici un petit exemple. Premièrement, sortiz le nom du thread de la méthode Main (). Ce fil est alloué par le JVM. Ouvrez ensuite 10 fils et nommez-les 1 ~ 10. Chaque thread sort après avoir sorti son propre nom.
classe publique threadExample {public static void main (String [] args) {System.out.println (thread.currentThread (). getName ()); for (int i = 0; i <10; i ++) {new thread ("" + i) {public void run () {System.out.println ("thread:" + getName () + "running"); } }.commencer(); }}}Il convient de noter que bien que l'ordre des threads de démarrage soit ordonné, l'ordre d'exécution n'est pas ordonné. C'est-à-dire que le thread 1 n'est pas nécessairement le premier thread à sortir son nom de la console. En effet, les threads sont exécutés en parallèle plutôt que séquentiellement. JVM et le système d'exploitation déterminent l'ordre d'exécution des threads, et l'ordre de démarrage n'est pas nécessairement le même que celui des threads.
Ce qui précède est une compilation des informations créées par les threads Java. Nous continuerons d'ajouter des informations pertinentes à l'avenir. Merci pour votre soutien pour ce site Web!