Méthodes pour créer et exécuter des threads Java

La classe de thread Java est également une classe d'objets, et ses instances héritent toutes de java.lang.Thread ou de ses sous-classes. Vous pouvez créer un thread en java de la manière suivante :

Tread thread = new Thread();

Pour exécuter le thread, vous pouvez appeler la méthode start() du 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 s'est terminé après avoir appelé cette méthode.

Il existe deux manières d'écrire du code qui est exécuté lorsqu'un thread est en cours d'exécution : l'une consiste à créer une instance de la sous-classe Thread et à remplacer la méthode run, et la seconde consiste à implémenter l'interface Runnable lors de la création du classe. Ensuite, nous expliquerons ces deux méthodes en détail :

Créer une sous-classe de Thread

Créez une instance de la sous-classe Thread et remplacez la méthode run La méthode run appellera la méthode start(). être exécuté par la suite. Un exemple est le suivant :

public class MyThread extends Thread {  public void run(){    System.out.println("MyThread running");  }}

Vous pouvez créer et exécuter la sous-classe Thread ci-dessus comme suit

MyThread myThread = new MyThread();myTread.start();

Une fois le thread démarré, la méthode start reviendra immédiatement sans attendre la méthode run. Renvoie uniquement une fois l'exécution terminée. C'est comme si la méthode run était exécutée sur un autre processeur. Lorsque la méthode run 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 Thread 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émentez l'interface Runnable

La deuxième façon d'écrire du code d'exécution de thread consiste à créer une nouvelle instance d'une classe qui implémente l'interface java.lang.Runnable. appelé par les threads. Un exemple est donné ci-dessous :

public class MyRunnable implements Runnable {  public void run(){   System.out.println("MyRunnable running");  }}

Afin de permettre au thread d'exécuter la méthode run(), l'objet instance de MyRunnable doit être passé dans le constructeur de la classe Thread. Un exemple est le suivant :

Thread thread = new Thread(new MyRunnable());thread.start();

Lorsque le thread est en cours d'exécution, il appellera la méthode run qui implémente l'interface Runnable. Dans l'exemple ci-dessus, « MyRunnable en cours d'exécution » sera imprimé.

De même, vous pouvez également 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 l'interface Runnable ?

Il n'y a pas de réponse définitive quant à savoir laquelle des deux méthodes est la meilleure, elles répondent toutes les deux aux exigences. À mon avis personnel, je préfère implémenter l'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 seront mis en file d'attente pour exécution jusqu'à ce que le pool de threads soit libre. Si les threads sont implémentés en implémentant une sous-classe Thread, cela sera plus compliqué.

Parfois, nous devons combiner les deux manières d'implémenter l'interface Runnable et la sous-classe Thread en même temps. Par exemple, une instance qui implémente une sous-classe Thread peut exécuter plusieurs threads qui implémentent l'interface Runnable. Une application typique est le pool de threads.

Erreur courante : appeler la méthode run() au lieu de la méthode start()

Une erreur courante lors de la création et de l'exécution d'un thread consiste à appeler la méthode run() du thread au lieu de start( ), comme indiqué ci-dessous :

Thread newThread = new Thread(MyRunnable());newThread.run();  //should be start();

Au début, vous ne ressentirez rien de mal, car la méthode run() est effectivement appelée comme vous l'espériez. Cependant, en fait, la méthode run() n'est pas exécutée par le nouveau thread qui vient d'être créé, mais par le thread actuel qui a créé le nouveau thread. C'est-à-dire exécuté par le thread qui exécute les deux lignes de code ci-dessus. Si vous souhaitez que le nouveau thread créé exécute la méthode run(), vous devez appeler la méthode start du nouveau thread.

Nom du fil de discussion

Lors de la création d'un fil de discussion, vous pouvez lui donner un nom. Cela nous aide à différencier les différents fils de discussion. Par exemple : si plusieurs threads écrivent dans System.out, nous pouvons facilement savoir quel thread génère via le nom du thread. Un exemple est le suivant :

MyRunnable runnable = new MyRunnable();Thread thread = new Thread(runnable, "New Thread");thread.start();System.out.println(thread.getName());

Il convient de noter que, comme MyRunnable n'est pas une sous-classe de Thread, la classe MyRunnable n'a pas de méthode getName(). Vous pouvez obtenir la référence du fil de discussion actuel de la manière suivante :

Thread.currentThread();

Vous pouvez donc obtenir le nom du fil de discussion actuel grâce au code suivant :

String threadName = Thread.currentThread().getName();

Code du fil de discussion exemple :
Voici un petit exemple. Tout d’abord, affichez le nom du thread exécutant la méthode main(). Ce thread est alloué par la JVM. Ensuite, démarrez 10 threads et nommez-les 1 à 10. Chaque thread se termine après avoir affiché son propre nom.

public class 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");           }        }.start();     } }}

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é. En d’autres termes, le thread n°1 n’est pas nécessairement le premier thread à afficher son nom sur la console. En effet, les threads s'exécutent en parallèle plutôt que séquentiellement. La JVM et le système d'exploitation déterminent l'ordre d'exécution des threads, et celui-ci n'est pas nécessairement cohérent avec l'ordre de démarrage des threads.

Recommandations associées :

Un exemple de code simple de compteur Java thread-safe

Analyse d'instance de synchronisation et d'asynchronisme d'objets en Java threads

attendre/notifier la communication entre les threads Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!