Java Tutorial/Thread/ThreadGroup

Add thread to thread group

class ThreadGroupDemo1 {
  public static void main(String[] args) {
    ThreadGroup tg = new ThreadGroup("My ThreadGroup");
    MyThread mt = new MyThread(tg, "My Thread");
    mt.start();
  }
}
class MyThread extends Thread {
  MyThread(ThreadGroup tg, String name) {
    super(tg, name);
  }
  public void run() {
    ThreadGroup tg = getThreadGroup();
    System.out.println(tg.getName());
  }
}

Demonstrate thread groups.

class NewThread extends Thread {
  boolean suspendFlag;
  NewThread(String threadname, ThreadGroup tgOb) {
    super(tgOb, threadname);
    suspendFlag = false;
    start();
  }
  public void run() {
    try {
      for (int i = 5; i > 0; i--) {
        System.out.println(getName() + ": " + i);
        Thread.sleep(1000);
        synchronized (this) {
          while (suspendFlag) {
            wait();
          }
        }
      }
    } catch (Exception e) {
      System.out.println("Exception in " + getName());
    }
  }
  void mysuspend() {
    suspendFlag = true;
  }
  synchronized void myresume() {
    suspendFlag = false;
    notify();
  }
}
class ThreadGroupDemo {
  public static void main(String args[]) {
    ThreadGroup groupA = new ThreadGroup("Group A");
    ThreadGroup groupB = new ThreadGroup("Group B");
    NewThread ob1 = new NewThread("One", groupA);
    NewThread ob2 = new NewThread("Two", groupA);
    NewThread ob3 = new NewThread("Three", groupB);
    NewThread ob4 = new NewThread("Four", groupB);
    groupA.list();
    groupB.list();
    Thread tga[] = new Thread[groupA.activeCount()];
    groupA.enumerate(tga); 
    for (int i = 0; i < tga.length; i++) {
      ((NewThread) tga[i]).mysuspend(); 
    }
    try {
      Thread.sleep(4000);
    } catch (InterruptedException e) {
      System.out.println("Main thread interrupted.");
    }
    System.out.println("Resuming Group A");
    for (int i = 0; i < tga.length; i++) {
      ((NewThread) tga[i]).myresume(); 
    }
    try {
      ob1.join();
      ob2.join();
      ob3.join();
      ob4.join();
    } catch (Exception e) {
      System.out.println("Exception in Main thread");
    }
  }
}

Get parent thread group

class Main {
  public static void main(String[] args) throws Exception {
    ThreadGroup tg = Thread.currentThread().getThreadGroup();
    MyThread mt1 = new MyThread(tg, "first");
    MyThread mt2 = new MyThread(tg, "second");
    mt1.start();
    mt2.start();
    ThreadGroup parent = tg.getParent();
    Thread[] list = new Thread[parent.activeCount()];
    int count = parent.enumerate(list, true);
    String[] thdinfo = new String[count];
    for (int i = 0; i < count; i++)
      thdinfo[i] = list[i].toString();
    mt1.join();
    mt2.join();
    for (int i = 0; i < count; i++)
      System.out.println(thdinfo[i]);
  }
}
class MyThread extends Thread {
  MyThread(ThreadGroup tg, String name) {
    super(tg, name);
  }
  public void run() {
    for (char c = "A"; c <= "Z"; c++)
      System.out.println(c);
    try {
      Thread.sleep(1000);
    } catch (InterruptedException e) {
    }
  }
}

Listing all threads and threadgroups in the VM

/*
 * Copyright (c) 2004 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 3nd Edition.
 * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
 * You may study, use, and modify it for any non-commercial purpose,
 * including teaching and use in open-source projects.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book, 
 * please visit http://www.davidflanagan.ru/javaexamples3.
 */
import java.awt.BorderLayout;
import java.io.PrintWriter;
import java.io.StringWriter;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
/**
 * This class contains a useful static method for listing all threads and
 * threadgroups in the VM. It also has a simple main() method so it can be run
 * as a standalone program.
 */
public class ThreadLister {
  /** Display information about a thread. */
  private static void printThreadInfo(PrintWriter out, Thread t, String indent) {
    if (t == null)
      return;
    out.println(indent + "Thread: " + t.getName() + "  Priority: " + t.getPriority()
        + (t.isDaemon() ? " Daemon" : "") + (t.isAlive() ? "" : " Not Alive"));
  }
  /** Display info about a thread group and its threads and groups */
  private static void printGroupInfo(PrintWriter out, ThreadGroup g, String indent) {
    if (g == null)
      return;
    int num_threads = g.activeCount();
    int num_groups = g.activeGroupCount();
    Thread[] threads = new Thread[num_threads];
    ThreadGroup[] groups = new ThreadGroup[num_groups];
    g.enumerate(threads, false);
    g.enumerate(groups, false);
    out.println(indent + "Thread Group: " + g.getName() + "  Max Priority: " + g.getMaxPriority()
        + (g.isDaemon() ? " Daemon" : ""));
    for (int i = 0; i < num_threads; i++)
      printThreadInfo(out, threads[i], indent + "    ");
    for (int i = 0; i < num_groups; i++)
      printGroupInfo(out, groups[i], indent + "    ");
  }
  /** Find the root thread group and list it recursively */
  public static void listAllThreads(PrintWriter out) {
    ThreadGroup current_thread_group;
    ThreadGroup root_thread_group;
    ThreadGroup parent;
    // Get the current thread group
    current_thread_group = Thread.currentThread().getThreadGroup();
    // Now go find the root thread group
    root_thread_group = current_thread_group;
    parent = root_thread_group.getParent();
    while (parent != null) {
      root_thread_group = parent;
      parent = parent.getParent();
    }
    // And list it, recursively
    printGroupInfo(out, root_thread_group, "");
  }
  /**
   * The main() method create a simple graphical user interface to display the
   * threads in. This allows us to see the "event dispatch thread" used by AWT
   * and Swing.
   */
  public static void main(String[] args) {
    // Create a simple Swing GUI
    JFrame frame = new JFrame("ThreadLister Demo");
    JTextArea textarea = new JTextArea();
    frame.getContentPane().add(new JScrollPane(textarea), BorderLayout.CENTER);
    frame.setSize(500, 400);
    frame.setVisible(true);
    // Get the threadlisting as a string using a StringWriter stream
    StringWriter sout = new StringWriter(); // To capture the listing
    PrintWriter out = new PrintWriter(sout);
    ThreadLister.listAllThreads(out); // List threads to stream
    out.close();
    String threadListing = sout.toString(); // Get listing as a string
    // Finally, display the thread listing in the GUI
    textarea.setText(threadListing);
  }
}