1. rejoignez le fil de discussion :
Pendant l'exécution du thread, vous souhaitez parfois qu'un autre thread s'exécute en premier, par exemple en divisant un gros problème en plusieurs petits problèmes, en attribuant des threads à chaque petit problème, mais une fois tous les petits problèmes traités, laissez le thread principal effectuer d'autres opérations. A ce moment, nous pouvons appeler la méthode join() des autres threads du thread principal pour bloquer le thread appelant (ici, le thread principal).
Exemple de code :
Copiez le code comme suit :
paquet org.frzh.thread ;
la classe publique JoinThread étend Thread{
//Fournir un constructeur paramétré pour définir le nom du thread
public JoinThread (nom de la chaîne) {
super(nom);
}
public void run() {
pour (int je = 0; je < 100; i++) {
System.out.println(getName() + " " + i);
}
}
public static void main (String[] arguments) {
//Démarre le fil enfant
new JoinThread("nouveau fil").start();
pour (int je = 0; je < 100; i++) {
si (je == 20) {
JoinThread jt = new JoinThread("thread à rejoindre");
jt.start();
//Le thread principal appelle la méthode join du thread jt, puis le thread principal doit attendre que jt ait fini de s'exécuter avant de pouvoir s'exécuter
essayer {
jt.join();
} catch (InterruptedException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + " " +i);
}
}
}
À l'origine, il y avait trois ensembles de threads (deux sous-threads et un thread principal). Lorsque i = 20, le thread principal est bloqué et doit attendre que le "thread rejoint" soit exécuté avant d'avoir une chance de s'exécuter, donc là. il n'y a que deux threads exécutés par la suite.
Trois formes surchargées de méthode join() :
join() : attend que le thread rejoint termine son exécution ;
join(long millis) : Le temps d'attente le plus long pour que le thread rejoint s'exécute est de quelques millisecondes. Après cela, même si le thread rejoint n'a pas fini de s'exécuter, il n'attendra plus ;
join(long millis, int nanos) : Le temps maximum d'attente pour l'exécution du thread rejoint est de millis millisecondes + nanos microsecondes. (Cette méthode est fondamentalement inutile).
2 : Fil de fond :
Il existe un thread qui s'exécute en arrière-plan et sa tâche est de servir d'autres threads. Ce thread est appelé « thread d'arrière-plan », « thread démon » ou « thread elfe ». Lorsque tous les threads de premier plan meurent, le thread d’arrière-plan meurt automatiquement.
Exemple de code :
Copiez le code comme suit :
paquet org.frzh.thread ;
la classe publique DaemonThread étend Thread{
public void run() {
pour (int je = 0; je < 1000; i++) {
System.out.println(getName() + " " +i);
}
}
public static void main (String[] arguments) {
DaemonThread dt = new DaemonThread();
//Définit ce fil comme fil d'arrière-plan
dt.setDaemon(true);
dt.start();
pour (int je = 0; je < 10; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
//Le thread de premier plan se termine, puis le thread d'arrière-plan dt se terminera également, donc il ne s'exécutera pas 999
}
}
Le thread principal est par défaut le thread de premier plan, les sous-threads créés par le thread de premier plan sont par défaut le thread de premier plan et les sous-threads créés par le thread d'arrière-plan sont par défaut le thread d'arrière-plan.
3. Fil de sommeil (sommeil) :
La méthode de jointure précédente consiste à laisser le thread appelant attendre que le thread rejoint termine son exécution avant de continuer, tandis que la méthode sleep() consiste à laisser le thread appelant se bloquer pendant un certain temps avant de rentrer dans l'état prêt et d'attendre d'être programmé. C’est pourquoi il est souvent utilisé pour suspendre l’exécution d’un programme.
Exemple de code :
Copiez le code comme suit :
paquet org.frzh.thread ;
importer java.util.Date ;
classe publique SleepThread{
public static void main (String[] arguments) {
pour (int je = 0; je < 10; i++) {
System.out.println("Heure actuelle : " + new Date());
essayer {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}
}
}
}
Deux méthodes de surcharge de la méthode sleep() :
sommeil vide statique (longs millis) : laissez le thread actuel faire une pause pendant quelques millis millisecondes et entrez dans l'état de blocage. Cette méthode est affectée par la précision et l'exactitude des minuteurs système et des planificateurs de threads.
Sommeil vide statique (long millis, int nanos) : mettez en pause les millisecondes + les nanos microsecondes et entrez dans l'état de blocage. Il sera également affecté par la précision et l'exactitude de la minuterie du système et du planificateur de threads. En principe, ce n'est pas nécessaire.
4. Rendement du fil :
La méthode rendement() est quelque peu similaire à la méthode sleep. Elle peut également suspendre le thread en cours d'exécution, mais elle ne bloquera pas le thread, mais le transférera simplement à l'état prêt (notez qu'il ne s'agit pas d'un état bloquant). La méthode rendement() ne donnera qu'aux threads avec la même priorité ou une priorité plus élevée une chance d'être exécutés, donc un thread peut être reprogrammé pour continuer l'exécution après avoir appelé cette méthode.
Exemple de code :
Copiez le code comme suit :
paquet org.frzh.thread ;
la classe publique YieldThread étend Thread{
public YieldThread() {
}
public YieldThread (nom de la chaîne) {
super(nom);
}
public void run() {
pour (int je = 0; je < 100; i++) {
System.out.println(getName() + " " +i);
si (je == 20) {
//Le fil de discussion actuel donne
Thread.rendement();
}
}
}
public static void main (String[] arguments) {
//Démarre deux threads simultanés
YieldThread yt1 = new YieldThread("Avancé");
//Définit yt1 comme priorité la plus élevée
yt1.setPriority(Thread.MAX_PRIORITY);
yt1.start();
YieldThread yt2 = new YieldThread("niveau bas");
yt2.setPriority(Thread.MIN_PRIORITY);
yt2.start();
/*
* Si la priorité n'est pas définie pour le thread, la priorité des deux threads est la même, donc les deux threads s'exécuteront alternativement, et lorsque rendement est appelé, l'autre thread s'exécutera ;
* Cependant, après avoir défini les priorités ci-dessus pour les deux threads respectivement, l'exécution avancée du thread vient de démarrer. Lorsque i=20, rendement est appelé, mais parce que la méthode rendement ne le fera que.
* Donnez des opportunités d'exécution aux threads avec la même priorité ou une priorité plus élevée, de sorte que le thread de haut niveau soit toujours en cours d'exécution à ce moment-là et ne sera pas donné aux threads de bas niveau.
*/
}
}
5 : Changer la priorité du thread :
C'est relativement simple, il suffit d'appeler la méthode d'instance setPriority(int priorité). Chaque thread a par défaut la même priorité que son thread parent, et le thread principal a par défaut la priorité normale (5). Java fournit des priorités de 1 à 10, et vous pouvez également utiliser trois constantes statiques :
MAX_PRIORITY : 10
MIN_PRIORITÉ : 1
NORM_PRIORITÉ : 5
Remarque : Bien que Java fournisse 10 priorités, différents systèmes prennent en charge différentes priorités. Essayez donc d'éviter d'utiliser directement des nombres compris entre 1 et 10 et utilisez des constantes statiques pour garantir une bonne portabilité.