Page History

final class HandleRequest implements Runnable {
  public void run() {
    // Do something
  }
}

public final }}. A group is assigned to a thread upon its creation. If the group name is not specified explicitly, the default group called {{main}} is assigned by the Java Virtual Machine (JVM). The convenience methods of the {{ThreadGroup}} class can be used to operate on all threads at once, such as, by using the {{interrupt()}} method. Another use is to reinforce layered security by confining threads into groups so that they do not interfere with each other. \[[JavaThreads 04|AA. Java References#JavaThreads 04]\]

While there may be a few benefits, the associated dangers demand deeper insight into the real utility of the {{ThreadGroup}} class. Several of the {{ThreadGroup}} APIs ({{allowThreadSuspension, resume, stop, suspend}}) have been deprecated and the remainder are seldom used because they offer little desirable functionality. Ironically, a few APIs are not even thread-safe. \[[Bloch 01|AA. Java References#Bloch 01]\]

A programmer may sometimes wish to enumerate all the threads in a group as a precursor to other operations. This is accomplished by using the {{activeCount()}} method that "Returns an estimate of the number of active threads in this thread group. " \[[API 06|AA. Java References#API 06]\]. Notice that there is no absolute word on whether it returns the exact count or not; the definition of _active_ also has a different connotation here. A thread that is constructed and not started is still counted by the {{activeCount()}} method as _active_. 

According to the Java API \[[API 06|AA. Java References#API 06]\], class {{ThreadGroup}} documentation:

{quote}
\[The {{enumerate}} method\] Copies into the specified array every active thread in this thread group and its subgroups. An application should use the {{activeCount}} method to get an estimate of how big the array should be. If the array is too short to hold all the threads, the extra threads are silently ignored. 
{quote}

Threads are removed from the thread array either when they are stopped or when their {{run()}} method has finished executing. As a result, if a thread is not started, it continues to reside in the array despite the loss of the original reference. \[[JavaThreads 99|AA. Java References#JavaThreads 99]\]

Using the {{ThreadGroup}} APIs to facilitate thread shutdown also has pitfalls. "One way is for the thread initiating the termination to join the other threads and so know when those threads have terminated. However, an application may have to maintain its own list of the threads it creates because simply inspecting the {{ThreadGroup}} may return library threads that do not terminate and for which join will not return." \[[JPL 06|AA. Java References#JPL 06]\].

h2. Noncompliant Code Example

This noncompliant code example shows a {{NetworkHandler}} class that maintains a _controller_ thread. This thread is responsible for spawning a new thread every time a new network connection request is received. For the sake of brevity, it is assumed that the _controller_ thread invokes two methods ({{method1()}} and {{method2()}}) in succession and waits for a few milliseconds. The {{method1()}} method creates and starts two threads that are equivalent to two consequent connection requests, and so does the {{method2()}} method. All threads are defined to belong to the same group, {{Chief}}.

{mc} The other surprise is that after enumerating array ta, Chief also consists of a thread called "main" {mc}

{code:bgColor=#FFcccc}
class NetworkHandler implements Runnable {
  private static ThreadGroup tg = new ThreadGroup("Chief");

  @Override public void run() {
    try {
      method1();
      method2();
      Thread.sleep(2000);
    } catch(InterruptedException e) {
      // Forward to handler
    }
  }

  public static void method1() throws InterruptedException {
    new Thread(tg, new HandleRequest(), "t1thread1").start(); // Start t1
    new Thread(tg, new HandleRequest(), "t2thread2").start(); // Start t2	
  }

  public static void method2() {			  
    new Thread(tg, new HandleRequest(), "t3").start(); // Start t3
    new Thread(tg, new HandleRequest(), "t4"thread3").start(); // Start t4		
  }
	
  public static void printThreadsprintActiveCount(Thread t, int point) {
    System.out.println("Active Threads in Thread Group " + t.getThreadGroup()tg.getName() +
 
       " at point(" + point + "):" + " " + ttg.activeCount());
  }

  public static void printEnumeratedThreads(Thread[] ta[], int len) {
    System.out.println("Enumerating all threads...");
    for (int i = 0; i < len; i++) {
      System.out.println("Thread " + i + " = " + ta[i].getName());
    }   
  }

  public static void main(String[] args) throws InterruptedException {
    // Start thread controller
    Thread tthread = new Thread(tg, new NetworkHandler(), "tcontroller");
    tthread.start();

	    // Gets the active count (insecure)
    Thread[] ta[] = new Thread[ttg.activeCount()];		

    printThreadsprintActiveCount(t, 1);  // At point 1 P1
    Thread.sleep(1000);  // Delay to demonstrate TOCTOU condition (race window)
    Thread.sleep(1000);
    // CountP2: changesthe becausethread ofcount initiationchanges ofas new threads between points 1 and 2are initiated
    printThreadsprintActiveCount(t, 2);  
    // AtIncorrectly uses pointthe 2, the(now stale) thread count changesobtained at P1
    int n = ttg.enumerate(ta); // Incorrectly
 uses the (now stale)// threadSilently countignores obtainednewly atinitiated pointthreads 1	
    printEnumeratedThreads(ta, n); //
 Silently ignores printing newly initiated threads
  }
}

class HandleRequest implements Runnable {
  public void run() {
    System.out.println("Active Threads in Thread Group " +   
     // Thread.currentThread().getThreadGroup().getName() + 
  (between P1 and P2)

    // This code destroys the thread group if it does 
    // not have any live threads
    "for (HandlerThread threadthr invoked: thista): {
 " + " " + Threadthr.activeCountinterrupt());	

      while(true) {} // Infinite loop to keep threads active for demonstration	thr.isAlive());
    }
    tg.destroy();
  }
}
{code}

There is a Time of Check-Time of Use 

public final class NetworkHandler {
  private final ExecutorService executor;

  NetworkHandler(int poolSize) {
    this.executor = Executors.newFixedThreadPool(poolSize);
  }

  public void startThreads() {
    for (int i = 0; i < 3; i++) {
      executor.execute(new HandleRequest());
    }
  }

  public void shutdownPool() {
    executor.shutdown();
  }

  public static void main(String[] args)  {
    NetworkHandler nh = new NetworkHandler(3);
    nh.startThreads();
    nh.shutdownPool();
  }
}