ThreadGroup in Java

ThreadGroup in Java kann als eine Sammlung von Threads definiert werden, die so erstellt wurden, dass sie als Einheit funktionieren. ThreadGroup in Java wird im Allgemeinen verwendet, wenn eine kombinierte Operation für eine Gruppe von Threads ausgeführt werden muss. ThreadGroup bietet eine effiziente Möglichkeit, mehrere Threads zu verwalten.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax:

Hier ist eine Syntax, wie ThreadGroup in Java erstellt und verwendet wird.

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
}
}

In der obigen Syntax haben wir eine ThreadGroup-Instanz und zwei Threads erstellt, die Teil der Thread-Gruppe sind. Wir haben eine Hauptklasse und eine Thread-Klasse, ist der Name des übergeordneten Threads.

Wie funktioniert ThreadGroup in Java?

• Eine Thread-Gruppe ist eine Sammlung mehrerer verwandter Threads. Die Thread-Gruppe ermöglicht Entwicklern die gleichzeitige Verarbeitung mehrerer Java-Threads und ist im Paket java.lang verfügbar.
• Intern kann man sich eine Thread-Gruppe als einen Baum vorstellen, in dem jeder Thread einen übergeordneten Thread hat, mit Ausnahme des übergeordneten Threads, dem kein übergeordneter Thread zugeordnet ist.
• Es ist zu beachten, dass ein Thread, der zu einer bestimmten Thread-Gruppe gehört, Zugriff auf Informationen über dieselbe Thread-Gruppe hat, zu der der Thread gehört; Es verfügt über keine Informationen über seine übergeordnete Thread-Gruppe oder eine andere Thread-Gruppe.

Hier ist die Beschreibung der in java.lang.ThreadGroup verfügbaren Konstruktoren:

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.

Konstruktor

Beschreibung

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.

public ThreadGroup(String name) Dieser Konstruktor wird zum Erstellen einer neuen Thread-Gruppe verwendet. Das übergeordnete Element dieser Thread-Gruppe ist dasselbe wie das übergeordnete Element des aktuell ausgeführten Threads. Dieser Konstruktor kann eine SecurityException auslösen, falls der aktuell laufende Thread keine Berechtigung zum Erstellen einer Thread-Gruppe hat. public ThreadGroup(ThreadGroupparentgroup,String name) Dieser Konstruktor erstellt eine Thread-Gruppe mit einer angegebenen Thread-Gruppe als übergeordnetem Element und einem angegebenen Namen. Dieser Konstruktor kann eine NullPointerException auslösen, wenn die angegebene Thread-Gruppe null ist, und eine SecurityException kann ausgelöst werden, wenn der aktuell ausgeführte Thread keine Berechtigung zum Erstellen einer Thread-Gruppe hat.

Hier ist die Liste einiger wichtiger Methoden, die in java.lang.ThreadGroup verfügbar sind:

Methode

Beschreibung

int activeCount() Diese Methode gibt die Anzahl der aktiven laufenden Threads zurück, die in einer bestimmten Thread-Gruppe verfügbar sind. int activeGroupCount() Diese Methode gibt die Anzahl der aktiven Thread-Gruppen zurück, die ausgeführt werden. destroy() Diese Methode zerstört die Thread-Gruppe und ihre Untergruppen, falls verfügbar. int enumerate(Thread arr[]) Der Aufruf dieser Methode fügt den Thread, der in der aufrufenden Thread-Gruppe verfügbar ist, in das Gruppenarray der Threads ein. int enumerate(Thread arr[], boolean recurse) Der Aufruf dieser Methode fügt den Thread, der in der aufrufenden Thread-Gruppe verfügbar ist, in das Gruppen-Array der Threads ein. Wenn das rekursive Flag wahr ist, werden auch Threads in Untergruppen zur Gruppe hinzugefügt. int enumerate(ThreadGroup[] thgrp) Diese Methode fügt die Untergruppen der aufrufenden Thread-Gruppe in das Thread-Gruppen-Array ein. int enumerate(ThreadGroup[] thgrp, boolean recursive) Diese Methode fügt die Untergruppen der aufrufenden Thread-Gruppe in das Thread-Gruppen-Array ein; Wenn das rekursive Flag auf true gesetzt ist, werden alle Untergruppen von Untergruppen zum Gruppenarray hinzugefügt.

Neben den oben aufgeführten Methoden gibt es auch andere Methoden, die je nach Bedarf eingesetzt werden können.

Beispiel für ThreadGroup in Java

Im Folgenden finden Sie ein Beispiel für ThreadGroup in Java: Beispiel

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());
}
}

Hier sehen wir, wie die Thread-Gruppe in Java verwendet wird.

Code:

Ausgabe:

Fazit Der obige Artikel erklärt klar die Funktionsweise der Thread-Gruppe in Java; Es handelt sich um eine integrierte Möglichkeit, mehrere Threads zu verwalten. Die oben beschriebenen Java-Codebeispiele zur Thread-Gruppe werden in Java-Anwendungen verwendet.

Das obige ist der detaillierte Inhalt vonThreadGroup in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!