Thread grouping in Java

Very often, threads are an imaginary thing for programmers that you don’t always need to remember. Today I will go a little further and tell you about another new instance for many of you – ThreadGroup. If you are not too comfortable with the topic of threads, I highly recommend that you first understand the very basics of the idea of threads and how they work.

So in short, based on the information contained on the official Oracle website (link):

A thread group represents a set of threads. In addition, a thread group can also include other thread groups. The thread groups form a tree in which every thread group except the initial thread group has a parent.

A thread is allowed to access information about its own thread group, but not to access information about its thread group’s parent thread group or any other thread groups.

The Default Thread Group

ThreadGroup ourThreadGroup = new ThreadGroup("Our group of Threads");
Thread ourThread = new Thread(ourThreadGroup, "Thread for our group");

ThreadGroup threadGroup = new ThreadGroup("Simple group of threads");
Thread oneThread = new Thread(threadGroup, "One thread");
ThreadGroup group = oneThread.getThreadGroup();
System.out.print(group);    // java.lang.ThreadGroup[name=Simple group of threads,maxpri=5]

public class CounterApp {
    public static void main(String[] args) {
        ThreadGroup groupNorm = new ThreadGroup("A group with normal priority");
        Thread threadOne = new SpeedThread(groupNorm, "A thread number 1");
        Thread threadTwo = new SpeedThread(groupNorm, "A thread number 2");

        System.out.println("ACTIVE: " + groupNorm.activeCount());    // ACTIVE: 2
    }
}

Methods operating on the group

They are used to write or read group (ThreadGroup object) attributes.

The ThreadGroup class provides many set and read attributes that apply to the group as a whole.
These attributes include following parameters:
– the maximum priority that a thread belonging to the group can have,
– the parameter indicating whether the group is a daemon („daemon” group),
– group name,
– group father.

The methods that set and read parameters of the ThreadGroup class operate at the group level. Thanks to them, you can read or change an attribute of the ThreadGroup class object without affecting any of the threads within the group. The group-level methods are as follows:
– getMaxPriority and setMaxPriority
– getDaemon and setDaemon
– getName
– getParent and parentOf
– toString

For example, if setMaxPriority changes the maximum priority of threads in a group, the attribute of only the object representing the group is changed, but the priorities of the threads themselves within the group remain unchanged.

Example: (creating a thread group and changing the priority value)

public static void main(String[] args) {
    ThreadGroup groupNorm = new ThreadGroup("A group with normal priority");
    Thread threadMax = new Thread(groupNorm, "A thread with maximum priority");

     // set Thread's priority to max (10)
    threadMax.setPriority(Thread.MAX_PRIORITY);

    // set ThreadGroup's max priority to normal (5)
    groupNorm.setMaxPriority(Thread.NORM_PRIORITY);

   System.out.printf("Group's maximum priority: %s\n", groupNorm.getMaxPriority());
   System.out.printf("Thread's priority: %s\n", threadMax.getPriority());
}

When a ThreadGroup groupNorm object is created, it inherits the maximum priority of the thread group it derives from (the father group). In this case it is the maximum (MAX_PRIORITY) set by the Java runtime system. Then a threadMax thread is created and assigned the maximum priority allowed by the Java runtime system. Next, the priority for the thread group is lowered to (NORM_PRIORITY). Calling the setMaxPriority method here does not affect the threadMax thread priority. So we have a situation where the threadMax thread has a priority of 10, which is higher than the maximum priority of the groupNorm group it belongs to.

The output of the program is:

Group's maximum priority: 5
Thread's priority: 10 

So the setMaxPriority method only affects threads in the group that were created before it was called. Instead, it affects all new threads created in the group, all subgroups, and threads for which the setPriority method was called. Similarly, the daemon status change will apply only to new threads in the group and subsequent subgroups. The „daemon” status of a thread group means that the group will be destroyed if all threads in the group have terminated.