ThreadGroup en Java

ThreadGroup en Java peut être défini comme une collection de threads créés pour fonctionner comme une unité, ThreadGroup en Java est généralement utilisé lorsqu'il est nécessaire d'effectuer une opération combinée sur un groupe de threads ; ThreadGroup offre un moyen efficace de gérer plusieurs threads.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe :

Voici une syntaxe de la façon dont ThreadGroup est créé et utilisé en Java.

package <packagename>;
public class <mainclassname>{
public static void main(String args[]){
// creating threadgroup object
ThreadGroup grp= new ThreadGroup(“<parent thread name>”);
// creating threads belonging to given thread group
<ThreadClassName> one =new <ThreadClassName>(“<threadname1>”, grp);
// creating first member of thread group
<ThreadClassName> two =new <ThreadClassName>(“<threadname2>”, grp);
// creating second member of thread group
}
}
class <ThreadClassName> extends Thread{
<ThreadClassName>(String threadName, ThreadGroup grp){
super(threadName,grp); // call to parent class constructor
start();      // start the thread
}
public void run(){
// implement required logic
}
}

Dans la syntaxe ci-dessus, nous avons créé une instance ThreadGroup et créé deux threads qui font partie du groupe de threads. Nous avons une classe principale et une classe de thread, est le nom du fil de discussion parent.

Comment fonctionne ThreadGroup en Java ?

• Un groupe de discussions est une collection de plusieurs discussions liées. Le groupe de threads permet aux développeurs de gérer plusieurs threads Java simultanément et est disponible dans le package java.lang.
• En interne, le groupe de threads peut être considéré comme une arborescence dans laquelle chaque thread a un parent, à l'exception du thread parent auquel aucun parent n'est associé.
• Il est à noter qu'un thread appartenant à un groupe de threads particulier a accès aux informations sur le même groupe de threads auquel appartient le thread ; il ne dispose d'aucune information sur son groupe de threads parent ou sur tout autre groupe de threads.

Voici la description des constructeurs disponibles dans java.lang.ThreadGroup :

Constructor	Description
public ThreadGroup(String name)	This constructor is used for creating a new thread group, the parent of this thread group is the same as the parent group of the currently executing thread. This constructor may throw SecurityException in case the currently running thread does not have permission to create a thread group.
public ThreadGroup(ThreadGroupparentgroup,String name)	This constructor creates a thread group with a specified thread group as a parent and specified name. This constructor may throw NullPointerException in case the specified thread group is null, and SecurityException may be thrown in case the currently running thread does not have permission to create a thread group.

Constructeur

Description

Method	Description
int activeCount()	This method returns the number of active running threads available in a given thread group.
int activeGroupCount()	This method returns the number of active thread groups running.
destroy()	This method destroys the thread group and its sub groups if available.
int enumerate(Thread arr[])	Call to this method puts the thread available in invoking thread group into the group array of threads.
int enumerate(Thread arr[], boolean recurse)	Call to this method puts the thread available in invoking thread group into the group array of threads; if the recursive flag is true, then threads in subgroups are also added to the group.
int enumerate(ThreadGroup[] thgrp)	This method puts the subgroups of the invoking thread group into the thread group array.
int enumerate(ThreadGroup[] thgrp, boolean recursive)	This method puts the subgroups of the invoking thread group into the thread group array; if the recursive flag is set to true, then all subgroups of subgroups are added to the group array.

Groupe de Threads public (Nom de la chaîne) Ce constructeur est utilisé pour créer un nouveau groupe de threads, le parent de ce groupe de threads est le même que le groupe parent du thread en cours d'exécution. Ce constructeur peut lancer SecurityException au cas où le thread en cours d'exécution n'aurait pas l'autorisation de créer un groupe de threads. public ThreadGroup(ThreadGroupparentgroup,String name) Ce constructeur crée un groupe de threads avec un groupe de threads spécifié comme parent et un nom spécifié. Ce constructeur peut lever NullPointerException si le groupe de threads spécifié est nul, et SecurityException peut être levée si le thread en cours d'exécution n'a pas l'autorisation de créer un groupe de threads.

Voici la liste de quelques méthodes importantes disponibles dans java.lang.ThreadGroup :

Méthode

Description

int activeCount() Cette méthode renvoie le nombre de threads en cours d'exécution actifs disponibles dans un groupe de threads donné. int activeGroupCount() Cette méthode renvoie le nombre de groupes de threads actifs en cours d'exécution. destroy() Cette méthode détruit le groupe de threads et ses sous-groupes s'ils sont disponibles. int enumerate(Thread arr[]) L'appel à cette méthode place le thread disponible lors de l'appel du groupe de threads dans le tableau de groupe de threads. int enumerate(Thread arr[], récurse booléenne) L'appel à cette méthode place le thread disponible lors de l'appel du groupe de threads dans le tableau de groupe de threads ; si l'indicateur récursif est vrai, alors les threads des sous-groupes sont également ajoutés au groupe. int enumerate(ThreadGroup[] thgrp) Cette méthode place les sous-groupes du groupe de threads appelant dans le tableau de groupes de threads. int enumerate(ThreadGroup[] thgrp, booléen récursif) Cette méthode place les sous-groupes du groupe de threads appelant dans le tableau de groupes de threads ; si l'indicateur récursif est défini sur true, alors tous les sous-groupes de sous-groupes sont ajoutés au tableau de groupes.

Outre les méthodes énumérées ci-dessus, il existe également d'autres méthodes qui peuvent être utilisées selon les besoins.

Exemple de ThreadGroup en Java

Vous trouverez ci-dessous l'exemple de ThreadGroup en Java : Exemple

package com.educba.threadgroupdemo;
import java.lang.*;
class ThreadDemo extends Thread
{
ThreadDemo(String threadname, ThreadGroup thgrp)
{
super(thgrp, threadname);
start();
}
public void run()
{
// implement required logic inside run method
for (int i = 0; i < 2000; i++)
{
try
{
Thread.sleep(20);
}
catch (InterruptedException e)
{
System.out.println("InterruptedException Exception encountered");
}
}
}
}
public class ThreadGroupDemo
{
public static void main(String args[])
{
// creating the thread group
ThreadGroup grp = new ThreadGroup("parent-thread");
// creating new thread and adding to thread group
ThreadDemo t1 = new ThreadDemo("first", grp);
System.out.println("Starting first thread");
// creating another thread and adding to thread group
ThreadDemo t2 = new ThreadDemo("two", grp);
System.out.println("Starting second thread");
// finding the number of active threads
System.out.println("Number of active threads running in thread group: "
+ grp.activeCount());
}
}

Ici, nous verrons comment le groupe de threads est utilisé en Java.

Code :

Sortie :

Conclusion L'article ci-dessus explique clairement le fonctionnement du groupe de threads en Java ; c'est un moyen intégré de gérer plusieurs threads. Les exemples de code Java décrits ci-dessus sur la manière de créer un groupe de threads sont utilisés dans les applications Java.

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!