java ThreadGroup源码分析

使用：

 import javax.swing.text.html.HTMLDocument.HTMLReader.IsindexAction;

 public class Test {

     public static void main(String[] args) {

         ThreadGroup tg = new ThreadGroup("threadGroup-001"); 

         Thread t1 = new Thread(tg, new MyThread());
         t1.start();

         Thread t2 = new Thread(tg, new MyThread());
         t2.start();

         // 返回线程组中活动线程的估计数
         System.out.println("active thread group: " + tg.activeCount());
         // 返回此线程组中活动线程组的估计数
         System.out.println("activeGroupCount: " + tg.activeGroupCount());
         // 检查当前运行的线程是否有权修改此线程组
         tg.checkAccess();
         // 设置线程组的最高优先级
         tg.setMaxPriority(6);
         // 返回此线程组的最高优先级
         System.out.println("maxPriority: " + tg.getMaxPriority());
         // 返回此线程组的名称
         System.out.println("thread group name: " + tg.getName());
         // 返回此线程组的父线程组
         System.out.println(tg.getParent());
         // 中断此线程组中的所有线程
         tg.interrupt();
         // 更改此线程组的后台程序状态
         tg.setDaemon(true);
         // 测试此线程组是否为一个后台程序线程组
         System.out.println("is daemon: " + tg.isDaemon());
         // 测试此线程组是否为线程组参数或其祖先线程组之一
         System.out.println("is parent: "+ tg.getParent().parentOf(tg));
         // 打印线程组信息
         tg.list();
         // 返回线程组的字符串表示形式
         System.out.println(tg.toString());
         // 销毁此线程组及其所有子组
         tg.destroy();
         // 测试此线程组是否已经销毁
         System.out.println(tg.isDestroyed());
 //        System.out.println(tg.);
     }

     private static class MyThread extends Thread {
         @Override
         public void run() {
             System.out.println("thread name: " + Thread.currentThread().getName());
         }
     }

 }

一、构造函数

　　两种构造函数：

ThreadGroup(String name) 

ThreadGroup(ThreadGroup parent, String name) 

　　

// 创建一个线程组必须关联到一个父线程组，默认父线程组是当前线程的线程组Thread.currentThread().getThreadGroup()。

// 并检查父线程组的权限。

public ThreadGroup(String name) {
    this(Thread.currentThread().getThreadGroup(), name);
}

 public ThreadGroup(ThreadGroup parent, String name) {
     this(checkParentAccess(parent), parent, name);
 }

// 初始化此线程组的名称（name）、最高优先级（maxPriority）、daemon、父线程组（parent）

// 并将此线程组添加到父线程组中（parent.add(this)）

 private ThreadGroup(Void unused, ThreadGroup parent, String name) {
     this.name = name;
     this.maxPriority = parent.maxPriority;
     this.daemon = parent.daemon;
     this.parent = parent;
     parent.add(this);
 }

// 添加一个线程组到此线程组

 private final void add(ThreadGroup g){
     synchronized (this) {
         if (destroyed) {
             throw new IllegalThreadStateException();
         }
         // 添加一个线程组到此线程组的groups数组中，groups初始容量为4，每次容量耗尽之后按2倍扩增。
         if (groups == null) {
             groups = new ThreadGroup[4];
         } else if (ngroups == groups.length) {
             groups = Arrays.copyOf(groups, ngroups * 2);
         }
         groups[ngroups] = g;

         // This is done last so it doesn't matter in case the
         // thread is killed
         ngroups++;
     }
 }

二、添加线程到线程组

 ThreadGroup tg = new ThreadGroup("threadGroup-001");
 Thread t1 = new Thread(tg, new MyThread());
 t1.start();

new Thread(tg, new MyThread()); 调用后，关于线程组相关的操作设置可在 private Thread(ThreadGroup g, Runnable target, String name,long stackSize, AccessControlContext acc,boolean inheritThreadLocals)看到：

 private Thread(ThreadGroup g, Runnable target, String name,
                    long stackSize, AccessControlContext acc,
                    boolean inheritThreadLocals) {
         if (name == null) {
             throw new NullPointerException("name cannot be null");
         }

         this.name = name;

         Thread parent = currentThread();
         SecurityManager security = System.getSecurityManager();
         if (g == null) {
             /* Determine if it's an applet or not */

             /* If there is a security manager, ask the security manager
                what to do. */
             if (security != null) {
                 g = security.getThreadGroup();
             }

             /* If the security manager doesn't have a strong opinion
                on the matter, use the parent thread group. */
             // 此线程没有明确指定线程组时，为其指定当前线程所在的线程组
             if (g == null) {
                 g = parent.getThreadGroup();
             }
         }

         /* checkAccess regardless of whether or not threadgroup is
            explicitly passed in. */
         g.checkAccess();

         /*
          * Do we have the required permissions?
          */
         if (security != null) {
             if (isCCLOverridden(getClass())) {
                 security.checkPermission(
                         SecurityConstants.SUBCLASS_IMPLEMENTATION_PERMISSION);
             }
         }

         // 调用类ThreadGroup的addUnstarted函数, 添加一个未启用的线程到线程组
         g.addUnstarted();

         // 设置当前线程的线程组
         this.group = g;
         this.daemon = parent.isDaemon();
         this.priority = parent.getPriority();
         if (security == null || isCCLOverridden(parent.getClass()))
             this.contextClassLoader = parent.getContextClassLoader();
         else
             this.contextClassLoader = parent.contextClassLoader;
         this.inheritedAccessControlContext =
                 acc != null ? acc : AccessController.getContext();
         this.target = target;
         setPriority(priority);
         if (inheritThreadLocals && parent.inheritableThreadLocals != null)
             this.inheritableThreadLocals =
                 ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
         /* Stash the specified stack size in case the VM cares */
         this.stackSize = stackSize;

         /* Set thread ID */
         this.tid = nextThreadID();
     }

主要操作：设置此线程的线程组，将线程组的未启动线程数加1（addUnstarted() 即nUnstartedThreads++)。

随后启动一个线程（t1.start()）：

  public synchronized void start() {
         /**
          * This method is not invoked for the main method thread or "system"
          * group threads created/set up by the VM. Any new functionality added
          * to this method in the future may have to also be added to the VM.
          *
          * A zero status value corresponds to state "NEW".
          */
         if (threadStatus != 0)
             throw new IllegalThreadStateException();

         /* Notify the group that this thread is about to be started
          * so that it can be added to the group's list of threads
          * and the group's unstarted count can be decremented. */
         group.add(this);

         boolean started = false;
         try {
             start0();
             started = true;
         } finally {
             try {
                 if (!started) {
                     group.threadStartFailed(this);
                 }
             } catch (Throwable ignore) {
                 /* do nothing. If start0 threw a Throwable then
                   it will be passed up the call stack */
             }
         }
     }

start()中的先调用 group.add(this)。然后线程启动失败后调用 group.threadStartFailed(this) 。

源码如下：

 void add(Thread t) {
         synchronized (this) {
             if (destroyed) {
                 throw new IllegalThreadStateException();
             }
             // ThreadGroup维护了一个数组，用来存放线程。
             if (threads == null) {
                 threads = new Thread[4];
             } else if (nthreads == threads.length) {
                 threads = Arrays.copyOf(threads, nthreads * 2);
             }
             // 添加线程到数组中
             threads[nthreads] = t;

             // This is done last so it doesn't matter in case the
             // thread is killed
             // 线程数组中线程数量增加1
             nthreads++;

             // The thread is now a fully fledged member of the group, even
             // though it may, or may not, have been started yet. It will prevent
             // the group from being destroyed so the unstarted Threads count is
             // decremented.
             // 未启动线程数减1
             nUnstartedThreads--;
         }
     }

 void threadStartFailed(Thread t) {
         synchronized(this) {
             // 线程组中移除线程t
             remove(t);
             // 未启动线程数增加1
             nUnstartedThreads++;
         }
     }

 private void remove(Thread t) {
         synchronized (this) {
             if (destroyed) {
                 return;
             }
             // 循环遍历查找线程t，并移除
             for (int i = 0 ; i < nthreads ; i++) {
                 if (threads[i] == t) {
                     System.arraycopy(threads, i + 1, threads, i, --nthreads - i);
                     // Zap dangling reference to the dead thread so that
                     // the garbage collector will collect it.
                     threads[nthreads] = null;
                     break;
                 }
             }
         }
     }

由上可见：只有调用start()成功启动的线程才会被它的线程组保存。

三、ThreadGroup的一些函数

1、destory() 销毁此线程组及其所有子组

 // 销毁此线程组及其所有子线程组
     public final void destroy() {
         int ngroupsSnapshot;
         ThreadGroup[] groupsSnapshot;
         synchronized (this) {
             checkAccess();
             if (destroyed || (nthreads > 0)) {
                 throw new IllegalThreadStateException();
             }
             // 子线程组数量
             ngroupsSnapshot = ngroups;
             // 子线程组数组
             if (groups != null) {
                 groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
             } else {
                 groupsSnapshot = null;
             }
             // 置空子线程数量、子线程组、子线程组数量、子线程组数组
             if (parent != null) {
                 destroyed = true;
                 ngroups = 0;
                 groups = null;
                 nthreads = 0;
                 threads = null;
             }
         }
         // 递归子线程组
         for (int i = 0 ; i < ngroupsSnapshot ; i += 1) {
             groupsSnapshot[i].destroy();
         }
         // 从父线程组中移除此线程组
         if (parent != null) {
             parent.remove(this);
         }
     }

2、interrupt() 中断此线程组中的所有线程（包括子线程组中的线程）

  // 中断此线程组中的所有线程（包括子线程组中的线程）
     public final void interrupt() {
         int ngroupsSnapshot;
         ThreadGroup[] groupsSnapshot;
         synchronized (this) {
             checkAccess();
             // 循环遍历线程组中的子线程，中断线程
             for (int i = 0 ; i < nthreads ; i++) {
                 threads[i].interrupt();
             }
             ngroupsSnapshot = ngroups;
             if (groups != null) {
                 groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
             } else {
                 groupsSnapshot = null;
             }
         }
         // 递归去子线程组执行interrupt()
         for (int i = 0 ; i < ngroupsSnapshot ; i++) {
             groupsSnapshot[i].interrupt();
         }
     }

3、setMaxPriority 设置线程组（包括子线程组）的最高优先级

  // 设置线程组（包括子线程组）的最高优先级
     public final void setMaxPriority(int pri) {
         int ngroupsSnapshot;
         ThreadGroup[] groupsSnapshot;
         synchronized (this) {
             checkAccess();
             // 检验优先级大小是否合规
             if (pri < Thread.MIN_PRIORITY || pri > Thread.MAX_PRIORITY) {
                 return;
             }
             // 最高优先级不能大于父线程组
             maxPriority = (parent != null) ? Math.min(pri, parent.maxPriority) : pri;
             ngroupsSnapshot = ngroups;
             if (groups != null) {
                 groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
             } else {
                 groupsSnapshot = null;
             }
         }
         // 递归设置子线程组的最高优先级
         for (int i = 0 ; i < ngroupsSnapshot ; i++) {
             groupsSnapshot[i].setMaxPriority(pri);
         }
     }

4、parentOf 判断是否为当前线程组的祖先线程组（或是否是当前线程组）

 // 判断g是否为当前线程组的祖先线程组（或是否是当前线程组）
     public final boolean parentOf(ThreadGroup g) {
         // 向上查找父线程组，直到父线程组为空，判断g是否为当前线程组的祖先线程组（或是否是当前线程组）
         for (; g != null ; g = g.parent) {
             if (g == this) {
                 return true;
             }
         }
         return false;
     }

5、activeCount 返回线程组中活动线程的估计数

 // 返回线程组中活动线程的估计数
     public int activeCount() {
         int result;
         // Snapshot sub-group data so we don't hold this lock
         // while our children are computing.
         int ngroupsSnapshot;
         ThreadGroup[] groupsSnapshot;
         synchronized (this) {
             if (destroyed) {
                 return 0;
             }
             // 线程组中的线程数
             result = nthreads;
             // 子线程组
             ngroupsSnapshot = ngroups;
             if (groups != null) {
                 groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
             } else {
                 groupsSnapshot = null;
             }
         }
         // 递归子孙线程组
         for (int i = 0 ; i < ngroupsSnapshot ; i++) {
             result += groupsSnapshot[i].activeCount();
         }
         return result;
     }

6、activeGroupCount 返回此线程组中活动线程组的估计数

 public int activeGroupCount() {
         int ngroupsSnapshot;
         ThreadGroup[] groupsSnapshot;
         synchronized (this) {
             if (destroyed) {
                 return 0;
             }
             // 子线程组数量
             ngroupsSnapshot = ngroups;
             if (groups != null) {
                 groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
             } else {
                 groupsSnapshot = null;
             }
         }
         int n = ngroupsSnapshot;
         // 递归子孙线程组
         for (int i = 0 ; i < ngroupsSnapshot ; i++) {
             n += groupsSnapshot[i].activeGroupCount();
         }
         return n;
     }

7、enumerate 所有活动线程复制到指定数组中

 // rescurse 否还包括作为此线程组的子组的线程组中的线程。
     // n 是list中已经存在的元素（线程）数量
     private int enumerate(Thread list[], int n, boolean recurse) {
         int ngroupsSnapshot = 0;
         ThreadGroup[] groupsSnapshot = null;
         synchronized (this) {
             if (destroyed) {
                 return 0;
             }
             // 线程组中的线程
             int nt = nthreads;
             // nt不能大于list的可用长度（递归遍历子孙线程组的时候，会带上n，所以此处要减去n）
             if (nt > list.length - n) {
                 nt = list.length - n;
             }
             for (int i = 0; i < nt; i++) {
                 if (threads[i].isAlive()) {
                     list[n++] = threads[i];
                 }
             }
             // 子孙线程组
             if (recurse) {
                 ngroupsSnapshot = ngroups;
                 if (groups != null) {
                     groupsSnapshot = Arrays.copyOf(groups, ngroupsSnapshot);
                 } else {
                     groupsSnapshot = null;
                 }
             }
         }
         // 递归子孙线程组
         if (recurse) {
             for (int i = 0 ; i < ngroupsSnapshot ; i++) {
                 n = groupsSnapshot[i].enumerate(list, n, true);
             }
         }
         // 返回已添加到list的线程数量
         return n;
     }