In Java, the ThreadGroup class creates a group of threads, and with the help of this, we can manage groups of threads as a unit. It is helpful when we need to control multiple threads as a single unit, such as suspending or resuming several related threads at once.
Features of the ThreadGroup Class:
- The thread group forms a tree in which every thread group except the initial thread group has a parent.
- A thread is allowed to access information about its thread group but not to access information about its thread group’s parent thread group or any other thread group.
Declaration of ThreadGroup Class
The Declaration of the ThreadGroup Class is listed below:
public class ThreadGroup extends Object implements Thread.UncaughtExceptionHandler
Constructors in ThreadGroup
This class consists of two constructors with the help of which we can create objects of this class in different ways. The following are the constructors available in this class:
1. public ThreadGroup(String name): Constructs a new thread group. The parent of this new group is the thread group of the currently running thread.
Syntax:
public ThreadGroup(String name)
2. public ThreadGroup(ThreadGroup parent, String name): Creates a new thread group. The parent of this new group is the specified thread group.
Syntax:
public ThreadGroup(ThreadGroup parent, String name)
Java ThreadGroup Methods
Now, we are going to discuss about each method one by one in detail:
1. int activeCount(): This method returns the number of threads in the group plus any group for which this thread is parent.
Syntax:
public int activeCount()
- Parameter: This method does not take any parameter
- Return Type: This method returns an estimate of the number of active threads in this thread group and in any other thread group that has this thread group as an ancestor.
Example:
Java
// Java Program to demonstrates the
// working of activeCount() method
import java.lang.*;
class NewThread extends Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super(tgob, threadname);
start();
}
public void run()
{
for (int i = 0; i < 1000; i++)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException ex)
{
System.out.println("Exception encounterted");
}
}
}
}
public class Geeks
{
public static void main(String arg[])
{
// creating the thread group
ThreadGroup t = new ThreadGroup("parent thread group");
NewThread t1 = new NewThread("one", t);
System.out.println("Starting one");
NewThread t2 = new NewThread("two", t);
System.out.println("Starting two");
// checking the number of active thread
System.out.println("number of active thread: "
+ t.activeCount());
}
}
Output:
2. int activeGroupCount(): This method returns an estimate of the number of active groups in this thread group.
Syntax:
public int activeGroupCount()
- Parameter: This method does not take any parameter
- Return Type: Returns the number of groups for which the invoking thread is parent.
Example:
Java
// Java program to demonstrates
// the working of activeGroupCount() method
import java.lang.*;
class NewThread extends Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super(tgob, threadname);
start();
}
public void run()
{
for (int i = 0; i < 1000; i++)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException ex)
{
System.out.println("Exception encounterted");
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing");
}
}
public class Geeks
{
public static void main(String arg[]) throws InterruptedException
{
// creating the thread group
ThreadGroup g = new ThreadGroup("gfg");
ThreadGroup gfg_child = new ThreadGroup(g, "child");
NewThread t1 = new NewThread("one", g);
System.out.println("Starting one");
NewThread t2 = new NewThread("two", g);
System.out.println("Starting two");
// checking the number of active thread
System.out.println("number of active thread group: "
+ g.activeGroupCount());
}
}
Output:
3. void checkAccess(): Causes the security manager to verify that the invoking thread may access and/ or change the group on which checkAccess() is called.
Syntax:
final void checkAccess()
- Parameter: This method does not take any parameter.
- Return Type: This method does not return anything.
Note: This method is now depricated.
4. void destroy(): Destroys the thread group and any child groups on which it is called.
Syntax:
public void destroy()
- Parameter: This method does not take any parameter
- Return Type: This method does not return anything.
Note: This method is now depricated.
5. int enumerate(Thread group[]): The thread that comprise the invoking thread group are put into the group array.
Syntax:
public int enumerate(Thread group[]).
- Parameter: This method takes a single parameter Thread group[], which is an aray of Thread objects.
- Return Type: Return the number of threads put into the array.
Example:
Java
// Java Program to demonstrates
// the working of enumerate() method.
import java.lang.*;
class NewThread extends Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super(tgob, threadname);
start();
}
public void run()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException ex) {
System.out.println("Exception encounterted");
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing");
}
}
public class Geeks
{
public static void main(String arg[]) throws InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup g = new ThreadGroup("Parent thread");
ThreadGroup gfg_child = new ThreadGroup(g, "child thread");
NewThread t1 = new NewThread("one", g);
System.out.println("Starting one");
NewThread t2 = new NewThread("two", g);
System.out.println("Starting two");
// returns the number of threads put into the array
Thread[] group = new Thread[g.activeCount()];
int count = g.enumerate(group);
for (int i = 0; i < count; i++)
{
System.out.println("Thread " + group[i].getName() + " found");
}
}
}
Output:
6. int enumerate(Thread[] group, boolean recurse): The threads that comprise the invoking thread group are put into the group array. If all is true, then threads in all subgroups of the thread are also put into group.
Syntax:
public int enumerate(Thread[] list, boolean recurse)
- Parameter: This method take two parameter.
- Thread[] list: It is an array of thread objects where all the threads will stored
- boolean recurse: If it’s true, then it includes threads from all subgroups and if false then only the threads in the current group is included.
- Return Type: Return the number of threads placed into the array.
Example:
Java
// Java program to demonstrates the
// working of enumerate(Thread[] group, boolean recurse)
import java.lang.*;
class NewThread extends Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super(tgob, threadname);
start();
}
public void run()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException ex)
{
System.out.println("Exception encounterted");
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing");
}
}
public class Geeks
{
public static void main(String arg[]) throws InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup g = new ThreadGroup("Parent thread");
ThreadGroup gfg_child = new ThreadGroup(g, "child thread");
NewThread t1 = new NewThread("one", g);
System.out.println("Starting one");
NewThread t2 = new NewThread("two", g);
System.out.println("Starting two");
// returns the number of threads put into the array
Thread[] group = new Thread[g.activeCount()];
int count = g.enumerate(group, true);
for (int i = 0; i < count; i++)
{
System.out.println("Thread " + group[i].getName() + " found");
}
}
}
Output:
7. int enumerate(ThreadGroup[] group): The subgroups of the evoking thread group are put into the group array.
Syntax:
public int enumerate(ThreadGroup[] group)
- Parameter: This method takes an array to store the subgroups.
- Return Type: Return the number of thread groups put into the array.
Example:
Java
// Java program to demonstrates the working
// of enumerate(ThreadGroup[] group) method
import java.lang.*;
class NewThread extends Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super(tgob, threadname);
start();
}
public void run()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException ex)
{
System.out.println("Exception encounterted");
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing");
}
}
public class Geeks
{
public static void main(String arg[]) throws InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup g = new ThreadGroup("Parent thread");
ThreadGroup gfg_child = new ThreadGroup(g, "child thread");
NewThread t1 = new NewThread("one", g);
System.out.println("Starting one");
NewThread t2 = new NewThread("two", g);
System.out.println("Starting two");
// returns the number of threads put into the array
ThreadGroup[] group = new ThreadGroup[g.activeCount()];
int count = g.enumerate(group);
for (int i = 0; i < count; i++)
{
System.out.println("ThreadGroup " + group[i].getName() +
" found");
}
}
}
Output:
8. int enumerate(ThreadGroup[] group, boolean all): The subgroups of the invoking thread group are put into the group array. If all is true, then all subgroups of the subgroups(and so on) are also put into group.
Syntax:
public int enumerate(ThreadGroup[] group, boolean all)
- Parameter: This method takes two parameters
- ThreadGroup: It is an array to store the subgroup
- boolean all: If it’s true then it includes subgroups and if it is false then it includes only immediate subgroups
- Return Type: Return the number of thread groups put into the array.
Example:
Java
// Java code to demonstrates the working
// of enumerate(ThreadGroup[] group, boolean all)
import java.lang.*;
class NewThread extends Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super(tgob, threadname);
start();
}
public void run()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException ex)
{
System.out.println("Exception encounterted");
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing");
}
}
public class Geeks
{
public static void main(String arg[]) throws InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup g = new ThreadGroup("Parent thread");
ThreadGroup gfg_child = new ThreadGroup(g, "child thread");
NewThread t1 = new NewThread("one", g);
System.out.println("Starting one");
NewThread t2 = new NewThread("two", g);
System.out.println("Starting two");
// returns the number of threads put into the array
ThreadGroup[] group = new ThreadGroup[g.activeCount()];
int count = g.enumerate(group, true);
for (int i = 0; i < count; i++)
{
System.out.println("ThreadGroup " + group[i].getName() +
" found");
}
}
}
Output:
9. int getMaxPriority(): Returns the maximum priority setting for the group.
Syntax:
final int getMaxPriority().
- Parameter: This method does not take any parameter
- Return Type: Return he maximum priority that a thread in this thread group can have.
Example:
Java
// Java code to demonstrates the
// working of getMaxPriority() method
import java.lang.*;
class NewThread extends Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super(tgob, threadname);
start();
}
public void run()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException ex)
{
System.out.println("Exception encounterted");
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing");
}
}
public class Geeks
{
public static void main(String arg[]) throws InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup g = new ThreadGroup("Parent thread");
ThreadGroup gfg_child = new ThreadGroup(g, "child thread");
// checking the maximum priority of parent thread
System.out.println("Maximum priority of ParentThreadGroup = "
+ g.getMaxPriority());
NewThread t1 = new NewThread("one", g);
System.out.println("Starting one");
NewThread t2 = new NewThread("two", g);
System.out.println("Starting two");
}
}
Output:
10. String getName(): This method returns the name of the group.
Syntax:
final String getName()
- Parameter: This method does not take any parameter.
- Return Type: Retrun the name of this thread group.
Example:
Java
// Java program to demonstrates the
// working of getName() method
import java.lang.*;
class NewThread extends Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super(tgob, threadname);
start();
}
public void run()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException ex)
{
System.out.println("Exception encounterted");
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing");
}
}
public class Geeks
{
public static void main(String arg[]) throws InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup g = new ThreadGroup("Parent thread");
ThreadGroup gfg_child = new ThreadGroup(g, "child thread");
NewThread t1 = new NewThread("one", g);
System.out.println("Starting " + t1.getName());
NewThread t2 = new NewThread("two", g);
System.out.println("Starting " + t2.getName());
}
}
Output:
11. ThreadGroup getParent(): Returns null if the invoking ThreadGroup object has no parent. Otherwise, it returns the parent of the invoking object.
Syntax:
final ThreadGroup getParent()
- Parameter: This method does not take any parameter
- Return Type: Return the parent of this thread group. The top-level thread group is the only thread group whose parent is null.
Example:
Java
// Java program to demonstrates the
// working of getParent() method
import java.lang.*;
class NewThread extends Thread {
NewThread(String threadname, ThreadGroup tgob)
{
super(tgob, threadname);
start();
}
public void run()
{
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(10);
}
catch (InterruptedException ex) {
System.out.println("Exception encounterted");
}
}
System.out.println(Thread.currentThread().getName()
+ " finished executing");
}
}
public class Geeks{
public static void main(String arg[]) throws InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup g = new ThreadGroup("Parent thread");
ThreadGroup gfg_child = new ThreadGroup(g, "child thread");
NewThread t1 = new NewThread("one", g);
System.out.println("Starting " + t1.getName());
NewThread t2 = new NewThread("two", g);
System.out.println("Starting " + t2.getName());
// prints the parent ThreadGroup
// of both parent and child threads
System.out.println("ParentThreadGroup for " + g.getName() +
" is " + g.getParent().getName());
System.out.println("ParentThreadGroup for " + gfg_child.getName()
+ " is " + gfg_child.getParent().getName());
}
}
Output:
12. void interrupt(): Invokes the interrupt() methods of all threads in the group.
Syntax:
public final void interrupt()
- Parameter: This method does not take any parameter.
- Return Type: This method does not return anything.
Example:
Java
// Java program to demonstrates the
// working of interrupt() method
import java.lang.*;
class NewThread extends Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super(tgob, threadname);
start();
}
public void run()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException ex)
{
System.out.println("Thread " + Thread.currentThread().getName()
+ " interrupted");
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing");
}
}
public class Geeks
{
public static void main(String arg[]) throws InterruptedException,
SecurityException
{
// creating the thread group
ThreadGroup g = new ThreadGroup("Parent thread");
ThreadGroup gfg_child = new ThreadGroup(g, "child thread");
NewThread t1 = new NewThread("one", g);
System.out.println("Starting " + t1.getName());
NewThread t2 = new NewThread("two", g);
System.out.println("Starting " + t2.getName());
// interrupting thread group
g.interrupt();
}
}
Output:
13. boolean isDaemon(): Tests if this thread group is a daemon thread group. A daemon thread group is automatically destroyed when its last thread is stopped or its last thread group is destroyed.
Syntax:
public final boolean isDaemon()
- Parameter: This method does not take any parameter.
- Return Type: Return true if the group is daemon group. Otherwise it returns false.
Note: This method is now depricated.
14. boolean isDestroyed(): This method tests if this thread group has been destroyed.
Syntax:
public boolean isDestroyed()
- Parameter: This method does not take any parameter.
- Return Type: Return true if this object is destroyed.
Note: This method is depricated.
15. void list(): Displays information about the group.
Syntax:
public void list()
- Parameter: This method does not take any parameter.
- Return Type: This method does not return anything.
Example:
Java
// Java program to demonstrates
// the working of list() method.
import java.lang.*;
class NewThread extends Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super(tgob, threadname);
start();
}
public void run()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException ex)
{
System.out.println("Thread " + Thread.currentThread().getName()
+ " interrupted");
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing");
}
}
public class Geeks
{
public static void main(String arg[]) throws InterruptedException,
SecurityException, Exception
{
// creating the thread group
ThreadGroup g = new ThreadGroup("Parent thread");
ThreadGroup gfg_child = new ThreadGroup(g, "child thread");
NewThread t1 = new NewThread("one", g);
System.out.println("Starting " + t1.getName());
NewThread t2 = new NewThread("two", g);
System.out.println("Starting " + t2.getName());
// listing contents of parent ThreadGroup
System.out.println("\nListing parentThreadGroup: " + g.getName()
+ ":");
// prints information about this thread group
// to the standard output
g.list();
}
}
Output:
16. boolean parentOf(ThreadGroup group): This method tests if this thread group is either the thread group argument or one of its ancestor thread groups.
Syntax:
final boolean parentOf(ThreadGroup group)
- Parameter: It represent the thread group to be checked if it is a parent of the current thread group.
- Return Type: Return true if the invoking thread is the parent.
Example:
Java
// Java program to demonstrates
// the working of parentOf() method
import java.lang.*;
class NewThread extends Thread
{
NewThread(String threadname, ThreadGroup tgob)
{
super(tgob, threadname);
start();
}
public void run()
{
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException ex)
{
System.out.println("Thread " + Thread.currentThread().getName()
+ " interrupted");
}
}
System.out.println(Thread.currentThread().getName() +
" finished executing");
}
}
public class Geeks
{
public static void main(String arg[]) throws InterruptedException,
SecurityException, Exception
{
// creating the thread group
ThreadGroup g = new ThreadGroup("Parent thread");
ThreadGroup gfg_child = new ThreadGroup(g, "child thread");
NewThread t1 = new NewThread("one", g);
System.out.println("Starting " + t1.getName());
NewThread t2 = new NewThread("two", g);
System.out.println("Starting " + t2.getName());
// checking who is parent thread
if (g.parentOf(gfg_child))
System.out.println(g.getName() + " is parent of " +
gfg_child.getName());
}
}
Output:
17. void setDaemon(boolean isDaemon): This method changes the daemon status of this thread group. A daemon thread group is automatically destroyed when its last thread is stopped or its last thread group is destroyed.
Syntax:
final void setDaemon(boolean isDaemon)
- Parameter: It specifies whether the thread is a demon thread or a user thread.
- Return Type: If isDaemon is true, then the invoking group is flagged as a daemon group.
Note: This method is depricated.
18. void setMaxPriority(int priority): Sets the maximum priority of the invoking group to priority.
Syntax:
final void setMaxPriority(int priority)
- Parameter: The parameter priority, sets the maximum priority level fot threads in the thread group.
- Return Type: This method does not return anything.
Example:
Java
// Java program to demonstrates
// the wokring of setMaxPriority() method
import java.lang.*;
class NewThread extends Thread {
NewThread(String threadname, ThreadGroup tgob) {
super(tgob, threadname);
}
public void run() {
for (int i = 0; i < 10; i++) {
try {
Thread.sleep(10);
} catch (InterruptedException ex) {
System.out.println("Thread " + Thread.currentThread().getName() + " interrupted");
}
}
System.out.println(Thread.currentThread().getName() + " [priority = " +
Thread.currentThread().getPriority() + "] finished executing.");
}
}
public class Geeks {
public static void main(String arg[]) throws InterruptedException {
// creating the thread group
ThreadGroup g = new ThreadGroup("Parent thread");
ThreadGroup gfg_child = new ThreadGroup(g, "child thread");
// Setting the maximum priority for the thread groups
g.setMaxPriority(Thread.MAX_PRIORITY - 2);
gfg_child.setMaxPriority(Thread.NORM_PRIORITY);
// Creating threads
NewThread t1 = new NewThread("one", g);
// Ensure priority is within group limit
t1.setPriority(Math.min(Thread.MAX_PRIORITY, g.getMaxPriority()));
System.out.println("Starting " + t1.getName());
t1.start();
NewThread t2 = new NewThread("two", gfg_child);
t2.setPriority(Math.min(Thread.MAX_PRIORITY, gfg_child.getMaxPriority())); // Ensure priority is within group limit
System.out.println("Starting " + t2.getName());
t2.start();
}
}
Output:
19. String toString(): This method returns a string representation of this Thread group.
Syntax:
public String toString()
- Parameter: This method does not take any parameter.
- Return Type: Return String equivalent of the group.
Note: This method is now depricated.
Similar Reads
Java Thread Class
Thread is a line of execution within a program. Each program can have multiple associated threads. Each thread has a priority which is used by the thread scheduler to determine which thread must run first. Java provides a thread class that has various method calls to manage the behavior of threads b
5 min read
Java Reader Class
Reader class in Java is an abstract class used for reading character streams. It serves as the base class for various subclasses like FileReader, BufferedReader, CharArrayReader, and others, which provide more efficient implementations of the read() method. To work with the Reader class, we must ext
7 min read
Java Writer Class
Java writer class is an abstract class in the java.io package. It is designed for writing character streams. Writer class in Java provides methods for writing characters, arrays of characters, and strings. Since it is an abstract class, we cannot create an instance of it directly. Instead, we will u
5 min read
Sealed Class in Java
In Java, we have the concept of abstract classes. It is mandatory to inherit from these classes since objects of these classes cannot be instantiated. On the other hand, there is a concept of a final class in Java, which cannot be inherited or extended by any other class. What if we want to restrict
2 min read
Stack Class in Java
The Java Collection framework provides a Stack class, which implements a Stack data structure. The class is based on the basic principle of LIFO (last-in-first-out). Besides the basic push and pop operations, the class also provides three more functions, such as empty, search, and peek. The Stack cl
12 min read
Wrapper Classes in Java
A Wrapper class in Java is one whose object wraps or contains primitive data types. When we create an object in a wrapper class, it contains a field, and in this field, we can store primitive data types. In other words, we can wrap a primitive value into a wrapper class object. Let's check on the wr
6 min read
Static class in Java
Java allows a class to be defined within another class. These are called Nested Classes. Classes can be static which most developers are aware of, henceforth some classes can be made static in Java. Java supports Static Instance Variables, Static Methods, Static Block, and Static Classes. The class
3 min read
JavaBean class in Java
JavaBeans are classes that encapsulate many objects into a single object (the bean). It is a Java class that should follow the following conventions: Must implement Serializable.It should have a public no-arg constructor.All properties in java bean must be private with public getters and setter meth
3 min read
Multithreading in Java
Multithreading is a Java feature that allows the concurrent execution of two or more parts of a program for maximum utilization of the CPU. Each part of such a program is called a thread. So, threads are lightweight processes within a process. Different Ways to Create ThreadsThreads can be created b
3 min read
Java Program Without Making Class
In Java, the easiest way to run a program is by creating a class with a main() method. But there is one more interesting thing that is, we can run a Java program without explicitly creating a class, instead, we can use enum. In this article, we are going to discuss how it works. What is Enum in Java
2 min read