Exemples et méthodes d'utilisation des groupes de threads en Java

Groupe de threads (classe ThreadGroup) en Java

La classe ThreadGroup est utilisée en Java pour représenter un groupe de threads, qui représente une collection de threads et peut gérer un lot de threads et de groupes de threads. Les threads peuvent être affectés à un certain groupe de threads. Il peut y avoir des objets de thread dans le groupe de threads, il peut également y avoir des groupes de threads, et il peut également y avoir des threads dans le groupe. Cette structure organisationnelle est quelque peu similaire à la forme d'une arborescence. comme le montre la figure.

Tous les threads créés par l'utilisateur appartiennent au groupe de threads spécifié. Si aucun groupe de threads n'est explicitement spécifié, le thread appartient au groupe de threads par défaut (c'est-à-dire le groupe de threads principal). Par défaut, le thread enfant et le thread parent se trouvent dans le même groupe de threads.

De plus, le groupe de threads auquel appartient un thread ne peut être spécifié que lors de sa création. Le groupe de threads auquel appartient un thread ne peut pas être modifié pendant l'exécution du thread. ne peut pas être modifié une fois spécifié.

2. Pourquoi utiliser des groupes de discussions

1.Sécurité

Les threads du même groupe de threads peuvent modifier les données de chacun. Mais s'ils se trouvent dans des groupes de threads différents, alors les données ne peuvent pas être modifiées en « groupes inter-threads » et la sécurité des données peut être garantie dans une certaine mesure.

2. Gestion des lots

Les threads ou les objets de groupe de threads peuvent être gérés par lots pour organiser ou contrôler efficacement les threads ou les objets de groupe de threads.

3. Exemple d'utilisation d'un groupe de discussions

1. Groupe de fils d'association de fils : association de premier niveau

L'association dite de premier niveau signifie que l'objet parent a des objets enfants, mais qu'aucun objet petit-enfant n'est créé. Par exemple, créez un groupe de threads, puis attribuez les threads créés au groupe pour gérer efficacement ces threads. L'exemple de code est le suivant :

public class ThreadGroupTest {
 public static void main(String[] args) {
 ThreadGroup rootThreadGroup = new ThreadGroup("root线程组");
 Thread thread0 = new Thread(rootThreadGroup, new MRunnable(), "线程A");
 Thread thread1 = new Thread(rootThreadGroup, new MRunnable(), "线程B");
 thread0.start();
 thread1.start();
 }
}
class MRunnable implements Runnable {
 @Override
 public void run() {
 while (!Thread.currentThread().isInterrupted()) {
 System.out.println("线程名: " + Thread.currentThread().getName() 
+ ", 所在线程组: " + Thread.currentThread().getThreadGroup().getName()) ;
 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 }
}
复制代码

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

线程名: 线程A, 所在线程组: root线程组
线程名: 线程B, 所在线程组: root线程组
复制代码

2. Groupe de fils d'association de fils : association multi-niveaux

La soi-disant association multi-niveaux signifie que l'objet parent a des objets enfants, et la création d'un objet petit-enfant dans l'objet enfant aura l'effet de descendants. Par exemple, utilisez la deuxième méthode de construction dans la figure ci-dessous pour attribuer le groupe de sous-threads à un certain groupe de threads, puis attribuez le thread créé au groupe de sous-threads. Cela aura l'effet d'une arborescence de threads.

L'exemple de code est le suivant :

public class ThreadGroupTest {
 public static void main(String[] args) {
 ThreadGroup rootThreadGroup = new ThreadGroup("root线程组");
 Thread thread0 = new Thread(rootThreadGroup, new MRunnable(), "线程A");
 Thread thread1 = new Thread(rootThreadGroup, new MRunnable(), "线程B");
 thread0.start();
 thread1.start();
 ThreadGroup threadGroup1 = new ThreadGroup(rootThreadGroup, "子线程组");
 Thread thread2 = new Thread(threadGroup1, new MRunnable(), "线程C");
 Thread thread3 = new Thread(threadGroup1, new MRunnable(), "线程D");
 thread2.start();
 thread3.start();
 }
}
class MRunnable implements Runnable {
 @Override
 public void run() {
 while (!Thread.currentThread().isInterrupted()) {
 System.out.println("线程名: " + Thread.currentThread().getName()
 + ", 所在线程组: " + Thread.currentThread().getThreadGroup().getName()
 + ", 父线程组: " + Thread.currentThread().getThreadGroup().getParent().getName());
 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 }
}
复制代码

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

线程名: 线程A, 所在线程组: root线程组, 父线程组: main
线程名: 线程B, 所在线程组: root线程组, 父线程组: main
线程名: 线程C, 所在线程组: 子线程组, 父线程组: root线程组
线程名: 线程D, 所在线程组: 子线程组, 父线程组: root线程组
复制代码

3. Gestion par lots des threads du groupe

Naturellement, l'utilisation d'un groupe de threads nécessite une gestion par lots des threads. Par exemple, vous pouvez interrompre par lots les threads du groupe. L'exemple de code est le suivant :

public class ThreadGroupTest {
 public static void main(String[] args) {
 ThreadGroup rootThreadGroup = new ThreadGroup("root线程组");
 Thread thread0 = new Thread(rootThreadGroup, new MRunnable(), "线程A");
 Thread thread1 = new Thread(rootThreadGroup, new MRunnable(), "线程B");
 thread0.start();
 thread1.start();
 ThreadGroup threadGroup1 = new ThreadGroup(rootThreadGroup, "子线程组");
 Thread thread2 = new Thread(threadGroup1, new MRunnable(), "线程C");
 Thread thread3 = new Thread(threadGroup1, new MRunnable(), "线程D");
 thread2.start();
 thread3.start();
 rootThreadGroup.interrupt();
 System.out.println("批量中断组内线程");
 }
}
class MRunnable implements Runnable {
 @Override
 public void run() {
 while (!Thread.currentThread().isInterrupted()) {
 System.out.println("线程名: " + Thread.currentThread().getName()
 + ", 所在线程组: " + Thread.currentThread().getThreadGroup().getName()
 + ", 父线程组: " + Thread.currentThread().getThreadGroup().getParent().getName());
 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 break;
 }
 }
 System.out.println(Thread.currentThread().getName() + "执行结束");
 }
}
复制代码

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

线程名: 线程A, 所在线程组: root线程组, 父线程组: main
线程名: 线程B, 所在线程组: root线程组, 父线程组: main
线程名: 线程C, 所在线程组: 子线程组, 父线程组: root线程组
线程名: 线程D, 所在线程组: 子线程组, 父线程组: root线程组
批量中断组内线程
线程A执行结束
线程B执行结束
线程C执行结束
线程D执行结束
复制代码

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!