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 :
Copiez le code comme suit :
fil public ( );
fil de discussion public (cible exécutable);
public Thread (nom de la chaîne);
public Thread (cible exécutable, nom de chaîne);
public Thread (groupe ThreadGroup, cible Runnable);
public Thread (groupe ThreadGroup, nom de chaîne);
public Thread (groupe ThreadGroup, cible Runnable, nom de chaîne);
public Thread (groupe ThreadGroup, cible Runnable, nom de chaîne, long stackSize);
Cible exécutable
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 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 :
Copiez le code comme suit :
mythread du paquet ;
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();
}
}
Le code ci-dessus crée deux threads : thread1 et thread2. Les lignes 005 à 005 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 de l'exécution du code ci-dessus sont les suivants :
principal
Sujet-0
Sujet-1
Comme le montre la sortie ci-dessus, la sortie principale de la première ligne est le nom du thread principal. 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 :
Copiez le code comme suit :
mythread du paquet ;
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();
}
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 :
Copiez le code comme suit :
fil1:MonThread1
fil2:MonThread2
fil3 : thread-1
Comme le montre le résultat ci-dessus, les noms de thread de thread1 et thread2 ont été modifiés, tandis que le nom de thread de 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é tant que la méthode run ne sera pas exécutée. exécuté. 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.