Java ThreadGroup
ThreadGroup
is a container that is used to organize and manage threads. It acts like a folder that holds threads together.
Key Features and Usage
Creating a Thread Group: You can create a new thread group just like creating a folder and give it a name.
1
ThreadGroup group = new ThreadGroup("MyThreadGroup");
Adding Threads to a Thread Group: When creating a thread, you can specify which thread group the thread belongs to.
1
2
3
4
5
6
7
8
9
10
11Thread thread1 = new Thread(group, () -> {
// Work of thread 1
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " is running.");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + " was interrupted.");
}
}
}, "Thread-1");Controlling the Thread Group: You can perform operations on the entire thread group, such as interrupting all threads in the group.
1
group.interrupt(); // Interrupts all threads in the thread group
Handling Exceptions: You can set an uncaught exception handler for the thread group to handle exceptions from threads within the group.
1
2
3
4group.uncaughtException(Thread thread, Throwable exception) {
// Handle uncaught exceptions
System.out.println(thread.getName() + " threw exception: " + exception);
}
Example Code
Below is a complete example demonstrating the creation of a thread group, adding threads to the group, and controlling the threads within the group:
1 | public class ThreadGroupExample { |
Important Notes
- Not Recommended for Advanced Concurrency:
ThreadGroup
is not the best practice for thread management in advanced concurrent applications. It has limitations and lacks some features needed for modern concurrency control. - Use ExecutorService: For better thread management, it is recommended to use
ExecutorService
or other concurrency utilities provided by thejava.util.concurrent
package.
ThreadGroup
can be useful for basic thread grouping and simple thread management tasks, but for more robust and scalable solutions, prefer using higher-level concurrency frameworks.