2，ThreadGroup 概念以及用法

当一个任务需要多个子线程去处理业务，这时候不希望这些子线程杂乱无章，就需要把这些线程统一管理起来，这时候线程组就产生了。

ThreadGroup 常用方法讲解

activeCount() 返回此线程组中活动线程的估计数。
activeGroupCount() 返回此线程组中活动线程组的估计数。
enumerate(Thread[] list) 把此线程组及其子组中的所有活动线程复制到指定数组中。
enumerate(Thread[] list, boolean recurse) 把此线程组中的所有活动线程复制到指定数组中。
interrupt() 中断此线程组中的所有线程。

 1 package com.zyguo.thread;
 2 
 3 public class SleepRunnable implements Runnable{
 4     private int sleepTime;
 5     public SleepRunnable( int sleepTime ){
 6         this.sleepTime = sleepTime;
 7     }
 8     @Override
 9     public void run() {
10         try {
11             System.out.println( Thread.currentThread() + " begin sleep " + this.sleepTime );
12             Thread.sleep( sleepTime );
13             System.out.println( Thread.currentThread() + " end sleep " + this.sleepTime );
14         } catch (InterruptedException e) {
15             // TODO Auto-generated catch block
16             e.printStackTrace();
17         }
18     }
19 }

 1 package com.zyguo.thread;
 2 
 3 import java.util.ArrayList;
 4 
 5 
 6 public class ThreadGroupMain {
 7     public static void main(String[] args) {
 8         int threadNum = 10;
 9         final ThreadGroup tgroup = new ThreadGroup("test-threadgroup");
10         ArrayList<Thread> tList = new ArrayList<>();
11         //定义10个线程
12         for( int i = 0; i < threadNum; i++ ){
13             Thread t = new Thread( tgroup, new SleepRunnable( 5000 + i*1000) ,"test-thread-" + i);
14             tList.add( t );
15         }
16 
17         System.out.println("before start, activeCount=" + tgroup.activeCount() );
18 
19         //检验 enumerate 方法
20         Thread[] threads = new Thread[threadNum];
21         //获取所有的子线程
22         int num = tgroup.enumerate( threads );
23         System.out.println( "befor start thread, enumerate num=" + num );
24         for (Thread thread : tList) {
25             thread.start();
26             System.out.println("start thread = " + thread );
27         }
28         num = tgroup.enumerate( threads );
29         System.out.println( "all thread start, enumerate num=" + num );
30         
31         //监控线程的活动的子线程数
32         Thread t = new Thread( new Runnable() {
33             @Override
34             public void run() {
35                 int activeCount = tgroup.activeCount();
36                 while ( activeCount > 0 ) {
37                     System.out.println("activeCount=" + activeCount );
38                     try {
39                         Thread.sleep(1000);
40                     } catch (InterruptedException e) {
41                         e.printStackTrace();
42                     }
43                     activeCount = tgroup.activeCount();
44                 }
45                 System.out.println("all thread is stop, activeCount=" + activeCount );        
46             }
47         });
48         
49         t.start();
50         
51         
52         
53         
54         
55     }
56 }

结果如下

before start, activeCount=0
befor start thread, enumerate num=0
start thread = Thread[test-thread-0,5,test-threadgroup]
Thread[test-thread-0,5,test-threadgroup] begin sleep 5000
Thread[test-thread-1,5,test-threadgroup] begin sleep 6000
start thread = Thread[test-thread-1,5,test-threadgroup]
start thread = Thread[test-thread-2,5,test-threadgroup]
start thread = Thread[test-thread-3,5,test-threadgroup]
Thread[test-thread-3,5,test-threadgroup] begin sleep 8000
Thread[test-thread-2,5,test-threadgroup] begin sleep 7000
start thread = Thread[test-thread-4,5,test-threadgroup]
Thread[test-thread-4,5,test-threadgroup] begin sleep 9000
start thread = Thread[test-thread-5,5,test-threadgroup]
Thread[test-thread-5,5,test-threadgroup] begin sleep 10000
start thread = Thread[test-thread-6,5,test-threadgroup]
Thread[test-thread-6,5,test-threadgroup] begin sleep 11000
start thread = Thread[test-thread-7,5,test-threadgroup]
Thread[test-thread-7,5,test-threadgroup] begin sleep 12000
start thread = Thread[test-thread-8,5,test-threadgroup]
Thread[test-thread-8,5,test-threadgroup] begin sleep 13000
start thread = Thread[test-thread-9,5,test-threadgroup]
Thread[test-thread-9,5,test-threadgroup] begin sleep 14000
all thread start, enumerate num=10
activeCount=10
activeCount=10
activeCount=10
activeCount=10
activeCount=10
Thread[test-thread-0,5,test-threadgroup] end sleep 5000
activeCount=9
Thread[test-thread-1,5,test-threadgroup] end sleep 6000
activeCount=8
Thread[test-thread-2,5,test-threadgroup] end sleep 7000
activeCount=7
Thread[test-thread-3,5,test-threadgroup] end sleep 8000
activeCount=6
Thread[test-thread-4,5,test-threadgroup] end sleep 9000
activeCount=5
Thread[test-thread-5,5,test-threadgroup] end sleep 10000
activeCount=4
Thread[test-thread-6,5,test-threadgroup] end sleep 11000
activeCount=3
Thread[test-thread-7,5,test-threadgroup] end sleep 12000
activeCount=2
Thread[test-thread-8,5,test-threadgroup] end sleep 13000
activeCount=1
Thread[test-thread-9,5,test-threadgroup] end sleep 14000
all thread is stop, activeCount=0

附上 ThreadGroup 所有的api

方法摘要
`int`	`activeCount()` 返回此线程组中活动线程的估计数。
`int`	`activeGroupCount()` 返回此线程组中活动线程组的估计数。
`boolean`	`allowThreadSuspension(boolean b)` 已过时。此调用的定义取决于 suspend()，它被废弃了。更进一步地说，此调用的行为从不被指定。
`void`	`checkAccess()` 确定当前运行的线程是否有权修改此线程组。
`void`	`destroy()` 销毁此线程组及其所有子组。
`int`	`enumerate(Thread[] list)` 把此线程组及其子组中的所有活动线程复制到指定数组中。
`int`	`enumerate(Thread[] list, boolean recurse)` 把此线程组中的所有活动线程复制到指定数组中。
`int`	`enumerate(ThreadGroup[] list)` 把对此线程组中的所有活动子组的引用复制到指定数组中。
`int`	`enumerate(ThreadGroup[] list, boolean recurse)` 把对此线程组中的所有活动子组的引用复制到指定数组中。
`int`	`getMaxPriority()` 返回此线程组的最高优先级。
`String`	`getName()` 返回此线程组的名称。
`ThreadGroup`	`getParent()` 返回此线程组的父线程组。
`void`	`interrupt()` 中断此线程组中的所有线程。
`boolean`	`isDaemon()` 测试此线程组是否为一个后台程序线程组。
`boolean`	`isDestroyed()` 测试此线程组是否已经被销毁。
`void`	`list()` 将有关此线程组的信息打印到标准输出。
`boolean`	`parentOf(ThreadGroup g)` 测试此线程组是否为线程组参数或其祖先线程组之一。
`void`	`resume()` 已过时。此方法只用于联合 `Thread.suspend` 和 `ThreadGroup.suspend` 时，因为它们所固有的容易导致死锁的特性，所以两者都已废弃。有关详细信息，请参阅 Thread.suspend()。
`void`	`setDaemon(boolean daemon)` 更改此线程组的后台程序状态。
`void`	`setMaxPriority(int pri)` 设置线程组的最高优先级。
`void`	`stop()` 已过时。此方法具有固有的不安全性。有关详细信息，请参阅 Thread.stop()。
`void`	`suspend()` 已过时。此方法容易导致死锁。有关详细信息，请参阅 Thread.suspend()。
`String`	`toString()` 返回此线程组的字符串表示形式。
`void`	`uncaughtException(Thread t, Throwable e)` 当此线程组中的线程因为一个未捕获的异常而停止，并且线程没有安装特定 Thread.UncaughtExceptionHandler 时，由 Java Virtual Machine 调用此方法。