Thread Groups

A Thread Group in Java is a container that holds multiple threads and allows you to manage them as a single unit.

It simplifies multi-threaded application management by enabling bulk operations, monitoring, and organization of threads.

Treat multiple threads as one entity for bulk operations and monitoring.

---

Why Do We Need Thread Groups?

Thread groups are useful to:

• Organize threads logically in large applications.
• Control multiple threads together (pause, resume, or interrupt all threads in a group).
• Handle exceptions at the group level rather than individually.
• Monitor and diagnose active threads and subgroups efficiently.

---

Key Features of Thread Groups

1. Logical Organization – Groups related threads for easier management.
2. Hierarchical Structure – Supports parent–child groups forming a tree.
3. System Thread Group – All groups belong to the JVM-created system group; main group is a child.
4. Group-Level Operations – Bulk actions: interrupt, monitor, set priority.
5. Default Group – Threads without a specified group go to the main group.
6. Centralized Exception Handling – Handle uncaught exceptions at the group level.
7. Thread Monitoring – Track active threads and subgroups for debugging.
8. Priority Control – Set a maximum priority for all threads in the group.
9. Legacy Feature – Mainly for monitoring; modern applications use ExecutorService/thread pools.

---

Creating a Thread Group

A Thread Group is created using the ThreadGroup class. It allows you to group multiple threads together so they can be managed as a single unit.

Basic Syntax

ThreadGroupgroup=newThreadGroup("MyThreadGroup");

• "MyThreadGroup" is the name of the thread group.
• The group is automatically added under the current thread’s group (usually the main thread group).

---

Creating a Thread Group with a Parent Group

ThreadGroupparentGroup=newThreadGroup("ParentGroup");
ThreadGroupchildGroup=newThreadGroup(parentGroup,"ChildGroup");

• ChildGroup becomes a subgroup of ParentGroup.
• This creates a hierarchical structure.

Verify Parent–Child Relationship

System.out.println(childGroup.getParent().getName());

Output:

ParentGroup

---

Creating Threads Inside a Thread Group

ThreadGroup group = new ThreadGroup("WorkerGroup");

Thread t1 = new Thread(group, () -> {
    System.out.println(Thread.currentThread().getName() + " is running");
}, "Worker-1");

Thread t2 = new Thread(group, () -> {
    System.out.println(Thread.currentThread().getName() + " is running");
}, "Worker-2");

t1.start();
t2.start();

How to Check a Thread’s Group

System.out.println(t1.getThreadGroup().getName());

Output:

WorkerGroup

? Explanation

t1.getThreadGroup() and t1.getThreadGroup().getName() , both refer to the same thread group:

• t1.getThreadGroup() returns the ThreadGroup object to which the thread belongs.
• t1.getThreadGroup().getName() returns the name of that ThreadGroup.

---

Important ThreadGroup Methods

getName()

• Returns the name of the thread group.
• Mostly used for logging and debugging.

System.out.println(group.getName());

---

getParent()

• Returns the parent thread group.
• Helps understand the hierarchy of thread groups.

ThreadGroupparent= group.getParent();

---

activeCount()

• Returns an approximate number of active threads in the group.
• The value is not exact because threads may start or stop anytime.

intcount= group.activeCount();

---

activeGroupCount()

• Returns an estimate of active subgroups inside the group.
• Also an approximate value.

intsubGroups= group.activeGroupCount();

---

enumerate(Thread[] list)

• Copies active thread references into the given array.
• Useful for monitoring or debugging threads.

Thread[] threads =newThread[group.activeCount()];
group.enumerate(threads);

---

interrupt()

• Interrupts all threads in the group at once.
• Commonly used to stop or cancel work.

group.interrupt();

---

setMaxPriority(int p)

• Sets the maximum priority allowed for threads in the group.
• Threads in this group cannot exceed this priority.

group.setMaxPriority(Thread.NORM_PRIORITY);

---

Thread Group Hierarchy

Example tree structure:

System ThreadGroup
└── ParentGroup
       ├── ChildGroup1
       └── ChildGroup2

• Threads in subgroups can be monitored or managed through parent groups.

---

Example – Managing Thread Groups

ThreadGroupgroup=newThreadGroup("Workers");

Runnabletask= () -> {
    System.out.println(Thread.currentThread().getName() +" started");
try {
        Thread.sleep(2000);
    }catch (InterruptedException e) {
        System.out.println(Thread.currentThread().getName() +" interrupted");
    }
    System.out.println(Thread.currentThread().getName() +" finished");
};

Threadt1=newThread(group, task,"Worker-1");
Threadt2=newThread(group, task,"Worker-2");

t1.start();
t2.start();

// Interrupt all threads in the group after 1 second
newThread(() -> {
try {
        Thread.sleep(1000);
        group.interrupt();
    }catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

Sample Output:

Worker-1 started
Worker-2 started
Worker-1 interrupted
Worker-2 interrupted

---

Thread Group Exception Handling

Thread groups allow you to set an uncaught exception handler for all threads in the group:

group.setUncaughtExceptionHandler((t, e) -> {
    System.out.println(t.getName() +" threw exception: " + e.getMessage());
});

---

Best Practices

1. Avoid using ThreadGroup for controlling threads: Considered legacy; modern Java uses ExecutorService or ThreadPoolExecutor for efficient management.
2. Use for monitoring and diagnostics: Inspect active threads or group structure.
3. Handle exceptions at the group level for cleaner error management.
4. Do not rely on ThreadGroup for business logic control; prefer modern concurrency tools.

---

Summary

• Thread groups allow logical organization of threads.
• Enable bulk operations: interrupting, monitoring, or setting priorities for multiple threads.
• All threads in Java belong to a thread group.
• Groups can form hierarchies with parent and child groups.
• Thread groups are mostly useful for diagnostics, not controlling execution in modern applications.
• Modern alternative: ExecutorService and thread pools for production-level thread management.