Il existe deux manières de créer des threads 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 :
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. 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.
Groupe ThreadGroup
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.
longue taille de pile
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 page de x86 est de 4 Ko. Sous la plate-forme x86, la taille de pile de threads par défaut 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 :
la classe publique Thread1 étend Thread
{
exécution publique vide()
{
System.out.println(this.getName());
}
public static void main (String[] arguments)
{
System.out.println(Thread.currentThread().getName());
Thread1 thread1 = nouveau Thread1();
Thread1 thread2 = nouveau Thread1 ();
thread1.start();
thread2.start();
}
}
Les résultats de l'exécution du code ci-dessus sont les suivants :
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 d'autres threads dans le programme qu'il 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 possède un constructeur surchargé qui peut 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 :
la classe publique Thread2 étend Thread
{
chaîne privée qui ;
exécution publique vide()
{
System.out.println(who + ":" + this.getName());
}
public Thread2 (Chaîne qui)
{
super();
this.who = qui ;
}
public Thread2 (Chaîne who, Nom de la chaîne)
{
super(nom);
this.who = qui ;
}
public static void main (String[] arguments)
{
Thread2 thread1 = nouveau Thread2 ("thread1", "MonThread1");
Thread2 thread2 = nouveau Thread2 ("thread2");
Thread2 thread3 = nouveau Thread2 ("thread3");
thread2.setName("MonThread2");
thread1.start();
thread2.start();
thread3.start();
}
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 (nom de la chaîne) de la classe Thread est appelé, qui est super (nom) à 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 :
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é tant que la méthode run ne sera pas exécutée. exécuté. Si Si vous souhaitez utiliser le nom du thread dans la méthode run, il y aura un phénomène selon lequel bien que la méthode setName soit 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.