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 Tutorial
Java is a high-level, object-oriented programming language used to build web apps, mobile applications, and enterprise software systems. It is known for its Write Once, Run Anywhere capability, which means code written in Java can run on any device that supports the Java Virtual Machine (JVM).Java s
10 min read
Java OOP(Object Oriented Programming) Concepts
Java Object-Oriented Programming (OOPs) is a fundamental concept in Java that every developer must understand. It allows developers to structure code using classes and objects, making it more modular, reusable, and scalable.The core idea of OOPs is to bind data and the functions that operate on it,
13 min read
Java Interview Questions and Answers
Java is one of the most popular programming languages in the world, known for its versatility, portability, and wide range of applications. Java is the most used language in top companies such as Uber, Airbnb, Google, Netflix, Instagram, Spotify, Amazon, and many more because of its features and per
15+ min read
Arrays in Java
Arrays in Java are one of the most fundamental data structures that allow us to store multiple values of the same type in a single variable. They are useful for storing and managing collections of data. Arrays in Java are objects, which makes them work differently from arrays in C/C++ in terms of me
15+ min read
Inheritance in Java
Java Inheritance is a fundamental concept in OOP(Object-Oriented Programming). It is the mechanism in Java by which one class is allowed to inherit the features(fields and methods) of another class. In Java, Inheritance means creating new classes based on existing ones. A class that inherits from an
13 min read
Java Exception Handling
Exception handling in Java allows developers to manage runtime errors effectively by using mechanisms like try-catch block, finally block, throwing Exceptions, Custom Exception handling, etc.An Exception is an unwanted or unexpected event that occurs during the execution of a program (i.e., at runti
10 min read
Collections in Java
Any group of individual objects that are represented as a single unit is known as a Java Collection of Objects. In Java, a separate framework named the "Collection Framework" has been defined in JDK 1.2 which holds all the Java Collection Classes and Interface in it. In Java, the Collection interfac
15+ min read
Java Interface
An Interface in Java programming language is defined as an abstract type used to specify the behaviour of a class. An interface in Java is a blueprint of a behaviour. A Java interface contains static constants and abstract methods. Key Properties of Interface:The interface in Java is a mechanism to
12 min read
Polymorphism in Java
Polymorphism in Java is one of the core concepts in object-oriented programming (OOP) that allows objects to behave differently based on their specific class type. The word polymorphism means having many forms, and it comes from the Greek words poly (many) and morph (forms), this means one entity ca
7 min read
Java Programs - Java Programming Examples
In this article, we will learn and prepare for Interviews using Java Programming Examples. From basic Java programs like the Fibonacci series, Prime numbers, Factorial numbers, and Palindrome numbers to advanced Java programs.Java is one of the most popular programming languages today because of its
8 min read