ThreadGroup in Java

ThreadGroup in java can be defined as a collection of threads created to work as a unit, ThreadGroup in java is generally used when there is a need to perform a combined operation on a group of threads; ThreadGroup offers an efficient way to manage multiple threads.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Syntax:

Here is a syntax of how ThreadGroup is created and used in 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
}
}

In the above syntax, we have created a ThreadGroup instance and created two threads that are a part of the thread group. We have a main class, and a thread class, is the parent thread name’s name.

How ThreadGroup works in Java?

• A Thread Group is a collection of multiple related threads. Thread group allows developers to handle multiple java threads simultaneously and is available in java.lang package.
• Internally thread group can be thought of as a tree in which each thread has a parent, except the parent thread that does not have a parent associated with it.
• It is to be noted that a thread belonging to a particular thread group has access to information about the same thread group to which the thread belongs; it does not have any information about its parent thread group or any other thread group.

Here is the description of constructors available in java.lang.ThreadGroup:

Here is the list of some important methods available in java.lang.ThreadGroup:

Apart from the above-listed methods, there are other methods as well which can be used as per need.

Example of ThreadGroup in Java

Given below is the example of ThreadGroup in Java: Example

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

Code:

Output:

The above is the detailed content of ThreadGroup in Java. For more information, please follow other related articles on the PHP Chinese website!