Comment utiliser la classe Thread pour créer des threads en Java ?

Il existe deux manières de créer un thread en Java : en utilisant la classe Thread et en utilisant l'interface Runnable. Lorsque vous utilisez l'interface Runnable, vous devez créer une instance de Thread. Par conséquent, que vous créiez un thread via la classe Thread ou l'interface Runnable, vous devez créer une instance de la classe Thread ou de sa sous-classe. Le constructeur de la classe Thread a été surchargé huit fois. Le constructeur est le suivant :

public Thread( );  public Thread(Runnable target);  public Thread(String name);  public Thread(Runnable target, String name);  public Thread(ThreadGroup group, Runnable target);  public Thread(ThreadGroup group, String name);  public Thread(ThreadGroup group, Runnable target, String name);  public Thread(ThreadGroup group, Runnable target, String name, long stackSize);

Cible Runnable

Une instance d'une classe qui implémente l'interface Runnable. Il convient de noter que la classe Thread implémente également l'interface Runnable, par conséquent, les instances de classes héritées de la classe Thread peuvent également être transmises à ce constructeur en tant que cibles.

Nom de la chaîne

Le nom du fil de discussion. Ce nom peut être défini via la méthode setName de la classe Thread après avoir créé une instance de Thread. Si le nom du thread n'est pas défini, le thread utilise le nom du thread par défaut : Thread-N N est l'ordre dans lequel le thread est créé et est un entier positif non répétitif.

GroupeThreadGroup

Le groupe de threads auquel appartient le thread actuellement créé. Si aucun groupe de threads n'est spécifié, tous les threads sont ajoutés à un groupe de threads par défaut. Les détails sur les groupes de threads seront abordés en détail dans les chapitres suivants.

long stackSize

La taille de la pile de threads Cette valeur est généralement un multiple entier de la page CPU. Par exemple, la taille de la page x86 est de 4 Ko. Sous la plateforme x86, la taille par défaut de la pile de threads est de 12 Ko.

Une classe Java ordinaire peut devenir une classe thread tant qu'elle hérite de la classe Thread. Et le code du thread peut être exécuté via la méthode start de la classe Thread. Bien que les sous-classes de la classe Thread puissent être instanciées directement, la méthode run de la classe Thread doit être substituée dans la sous-classe pour exécuter réellement le code du thread. Le code suivant donne un exemple d'utilisation de la classe Thread pour créer un thread :

package mythread;      public class Thread1 extends Thread    {        public void run()        {            System.out.println(this.getName());        }        public static void main(String[] args)        {            System.out.println(Thread.currentThread().getName());            Thread1 thread1 = new Thread1();            Thread1 thread2 = new Thread1 ();            thread1.start();            thread2.start();        }    }

Le code ci-dessus crée deux threads : thread1 et thread2. Les lignes 005 à 008 du code ci-dessus sont la méthode d'exécution de la classe Thread1. Lorsque la méthode start est appelée sur les lignes 014 et 015, le système appelle automatiquement la méthode run. À la ligne 007, this.getName() est utilisé pour afficher le nom du thread actuel, étant donné que le nom du thread n'est pas spécifié lors de la création du thread, la sortie du nom du thread est la valeur par défaut du système, qui se présente sous la forme de Thread. -n. Le nom du thread principal est affiché sur la ligne 011.

Les résultats d'exécution du code ci-dessus sont les suivants :

main
Thread-0
Thread-1

Comme le montrent les résultats de sortie ci-dessus, la sortie principale dans la ligne *** est le nom du fil conducteur. Les Thread-1 et Thread-2 suivants sont respectivement les résultats de sortie de thread1 et thread2.

Remarque : tout programme Java doit avoir un thread principal. Généralement, le nom de ce thread principal est main. Ce n'est qu'en créant des threads supplémentaires dans le programme que celui-ci peut être considéré comme un véritable programme multithread. En d’autres termes, un programme multithread doit avoir plus d’un thread.

La classe Thread a un constructeur surchargé pour définir le nom du thread. En plus d'utiliser la méthode constructeur pour définir le nom du thread lors de la création d'un thread, vous pouvez également utiliser la méthode setName de la classe Thread pour modifier le nom du thread. Pour définir le nom du thread via le constructeur de la classe Thread, vous devez utiliser le constructeur public Thread(String name) de la classe Thread dans la sous-classe de Thread. Par conséquent, vous devez également ajouter un thread à transmettre dans la sous-classe de Thread. Constructeur de nom. Le code suivant donne un exemple de définition du nom du thread :

package mythread;   public class Thread2 extends Thread  {      private String who;       public void run()      {          System.out.println(who + ":" + this.getName());      }      public Thread2(String who)      {          super();          this.who = who;      }      public Thread2(String who, String name)      {          super(name);          this.who = who;      }      public static void main(String[] args)      {          Thread2 thread1 = new Thread2 ("thread1", "MyThread1");          Thread2 thread2 = new Thread2 ("thread2");          Thread2 thread3 = new Thread2 ("thread3");          thread2.setName("MyThread2");          thread1.start();          thread2.start();          thread3.start();      }

Il y a deux constructeurs dans la classe :

Ligne 011 : public sample2_2(String who)

Ce constructeur a un paramètre : who. Ce paramètre est utilisé pour identifier le thread actuellement créé. Le constructeur par défaut de Thread, public Thread(), est toujours appelé dans ce constructeur.

Ligne 016 : public sample2_2(String who, String name)

Le who dans ce constructeur a la même signification que le who dans le premier constructeur, et le paramètre name est le nom du thread. Dans ce constructeur, le constructeur public Thread(String name) de la classe Thread est appelé, qui est super(name) à la ligne 018.

Trois threads sont établis dans la méthode principale : thread1, thread2 et thread3. Parmi eux, thread1 définit le nom du thread via la méthode de construction, thread2 modifie le nom du thread via la méthode setName et thread3 ne définit pas le nom du thread.

Les résultats en cours d'exécution sont les suivants :

thread1:MyThread1
thread2:MyThread2
thread3:Thread-1

Comme le montrent les résultats de sortie ci-dessus, les noms de thread de thread1 et thread2 ont été modifiés, tandis que le thread le nom du thread3 est toujours la valeur par défaut : Thread-1. La raison pour laquelle le nom de thread de thread3 n'est pas Thread-2 mais Thread-1 est que le nom de thread2 a été spécifié à la ligne 026. Par conséquent, lorsque thread3 est démarré, le nom de thread de thread3 est défini sur Thread-1. Vous obtiendrez donc le résultat ci-dessus.

Remarque : vous pouvez utiliser setName pour définir le nom du thread avant et après l'appel de la méthode start. Cependant, l'utilisation de setName pour modifier le nom du thread après l'appel de la méthode start entraînera une incertitude, ce qui signifie que setName ne sera peut-être pas exécuté avant l'exécution. la méthode est exécutée. Si vous souhaitez utiliser le nom du thread dans la méthode run, il y aura un phénomène selon lequel même si la méthode setName est appelée, le nom du thread n'est pas modifié.

La méthode start de la classe Thread ne peut pas être appelée plusieurs fois. Par exemple, la méthode thread1.start() ne peut pas être appelée deux fois. Sinon, une IllegalThreadStateException sera levée.

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!