Créer et démarrer un thread Java

Le thread Java est un type d'objet similaire à tout autre objet. Un thread est une instance de la classe java.lang.Thread ou une instance d'une sous-classe de cette classe. En plus d'être un type d'objet, les threads Java peuvent également exécuter du code.

Créer et démarrer un fil de discussion

Créer un fil de discussion peut se faire comme ceci :

Thread thread = new Thread();

Afin de démarrez un thread Java, vous devez appeler la méthode start, comme ceci :

thread.start();

Cet exemple ne spécifie aucun code que le thread exécutera. Ce fil sera arrêté immédiatement après son démarrage.

Il existe deux façons de spécifier le code que ce fil doit exécuter. La première méthode consiste à créer une sous-classe de thread, puis à remplacer la méthode run(). La deuxième méthode consiste à transmettre un objet qui implémente l'interface Runnable au constructeur Thread. Les deux méthodes sont mentionnées ci-dessous.

Sous-classe de thread

La première façon consiste à spécifier le code qu'un thread exécutera, consiste à créer une sous-classe du thread et à remplacer le méthode run(). Cette méthode run() est exécutée par ce thread après avoir appelé la méthode start(). Voici un exemple :

public class MyThread extends Thread {

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

Pour créer et démarrer le fil de discussion ci-dessus, vous pouvez procéder comme suit :

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

Dès que le fil de discussion est démarré, le démarrage () méthode reviendra. Il n'attendra pas la fin de la méthode run(). Cette méthode run() sera exécutée par différents processeurs. Lorsque cette méthode run() est exécutée, elle imprimera le contenu texte "MyThread en cours d'exécution".

Vous pouvez également créer une sous-classe anonyme d'un fil de discussion comme ceci :

Thread thread = new Thread(){
    public void run(){
      System.out.println("Thread Running");
    }
  }

  thread.start();

Le résultat de cet exemple sera le même que ci-dessus.

Implémentation d'interface exécutable

La deuxième façon de spécifier le code qu'un thread doit exécuter consiste à créer un thread qui implémente java.lang. Interface exécutable d'une classe. Cet objet Runnable peut être exécuté par un thread.

Voici un exemple :

public class MyRunnable implements Runnable {

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

Pour que la méthode run soit exécutée par un thread, vous devez passer une instance MyRunnable au constructeur d'un thread. Voici un exemple :

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

Lorsque ce fil démarre, il appellera la méthode run de MyRunnable au lieu d'exécuter sa propre méthode run. L'exemple ci-dessus imprimera le texte "MyRunnable en cours d'exécution".

Vous pouvez également créer une implémentation anonyme comme celle-ci :

Runnable myRunnable = new Runnable(){

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

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

Hériter le fil de discussion ou implémenter l'interface ?

Il n'y a pas de règles ici quant à laquelle des deux méthodes est la meilleure. Les deux méthodes fonctionneront. Cependant, pour moi personnellement, je préfère implémenter l'interface Runnable et gérer les instances de cette implémentation en tant qu'instance Thread. Lorsqu'une implémentation de Runnable est exécutée par un pool de threads, il est simple de mettre les instances Runnable en file d'attente jusqu'à ce que les threads du pool soient libres. C'est un peu difficile à réaliser en utilisant une sous-classe Thread.

Habituellement, vous devez non seulement implémenter Runnable, mais également la sous-classe Thread. Par exemple, si vous créez une sous-classe Thread, vous pouvez exécuter plusieurs Runnable. Il s'agit d'un exemple typique d'implémentation d'un pool de threads.

Piège courant : appeler run() au lieu de start()

Lors de la création et du démarrage d'un fil de discussion, une erreur courante est d'appeler Thread's La méthode run remplace la méthode start, comme ceci :

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

Tout d'abord, vous ne remarquerez peut-être rien, car la méthode run de Runnable s'exécutera également comme prévu. Cependant, il ne sera pas exécuté par le nouveau thread que vous créez. La méthode run du thread qui a remplacé le thread qui l'a créé est exécutée. En d’autres termes, le thread sur lequel les deux lignes de code ci-dessus s’exécutent. Pour que la méthode run de l'instance de thread nouvellement créée soit appelée, vous devez appeler la méthode start.

Nom du fil de discussion

Lorsque vous créez un fil de discussion Java, vous pouvez lui donner un nom. Ce nom vous aide à distinguer les différents threads. Par exemple, si plusieurs threads écrivent cette sortie, il est possible de voir quel thread a écrit quel texte. Voici un exemple :

Thread thread = new Thread("New Thread") {
      public void run(){
        System.out.println("run by: " + getName());
      }
   };


   thread.start();
   System.out.println(thread.getName());

Notez l'argument du canal de caractères transmis au constructeur Thread. Cette chaîne est le nom du fil de discussion. Ce nom peut être obtenu via la méthode getName de Thread. Lors de l'exécution d'une implémentation Runnable, vous pouvez également transmettre un nom. Comme ce qui suit :

MyRunnable runnable = new MyRunnable();
   Thread thread = new Thread(runnable, "New Thread");

   thread.start();
   System.out.println(thread.getName());

Notez cependant que, comme la classe MyRunnable n'est pas une sous-classe de la classe Thread, elle ne peut pas accéder à la méthode getName() du thread qui l'exécute.

Thread.currentThread()

Cette méthode renvoie une référence à l'instance Thread du thread en cours d'exécution. De cette façon, vous pouvez accéder à l'objet Thread du thread qui exécute le bloc de code. Voici un exemple :

Thread thread = Thread.currentThread();

Une fois que vous avez une référence à un objet Thread, vous pouvez appeler des méthodes dessus. Par exemple, vous pouvez obtenir le nom du thread exécutant :

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

Instance de thread Java

这里有一个小的例子。首先它打印出来了正在执行的main方法的线程的名字。这个线程是被JVM分配的。然后启动了10个线程，以及给予他们所有作为名称（“”+i）的一个数字。每一个线程然后打印出名字，以及停止执行。

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();
    }
  }
}

注意，甚至如果线程是按顺序启动的（1,2,3等等）。他们可能也不会按顺序执行的，意味着线程1可能不是第一个打印出来的名字。这个就是为什么原则上线程是并行运行而不是顺序呢执行的原因了。这个JVM以及操作系统决定着线程执行的顺序。这个顺序每次在他们启动的时候都不会相同的。
以上就是创建以及启动一个Java线程的内容，更多相关内容请关注PHP中文网（www.php.cn）！