Java ThreadGroup Class (original) (raw)

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.