2，ThreadGroup 概念以及用法

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

ThreadGroup  常用方法讲解

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

package com.zyguo.thread;

public class SleepRunnable implements Runnable{
    private int sleepTime;
    public SleepRunnable( int sleepTime ){
        this.sleepTime = sleepTime;
    }
    @Override
    public void run() {
        try {
            System.out.println( Thread.currentThread() + " begin sleep " + this.sleepTime );
            Thread.sleep( sleepTime );
            System.out.println( Thread.currentThread() + " end sleep " + this.sleepTime );
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

package com.zyguo.thread;

import java.util.ArrayList;


public class ThreadGroupMain {
    public static void main(String[] args) {
        int threadNum = 10;
        final ThreadGroup tgroup = new ThreadGroup("test-threadgroup");
        ArrayList<Thread> tList = new ArrayList<>();
        //定义10个线程
        for( int i = 0; i < threadNum; i++ ){
            Thread t = new Thread( tgroup, new SleepRunnable( 5000 + i*1000) ,"test-thread-" + i);
            tList.add( t );
        }

        System.out.println("before start, activeCount=" + tgroup.activeCount() );

        //检验 enumerate 方法
        Thread[] threads = new Thread[threadNum];
        //获取所有的子线程
        int num = tgroup.enumerate( threads );
        System.out.println( "befor start thread, enumerate num=" + num );
        for (Thread thread : tList) {
            thread.start();
            System.out.println("start thread = " + thread );
        }
        num = tgroup.enumerate( threads );
        System.out.println( "all thread start, enumerate num=" + num );
        
        //监控线程的活动的子线程数
        Thread t = new Thread( new Runnable() {
            @Override
            public void run() {
                int activeCount = tgroup.activeCount();
                while ( activeCount > 0 ) {
                    System.out.println("activeCount=" + activeCount );
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    activeCount = tgroup.activeCount();
                }
                System.out.println("all thread is stop, activeCount=" + activeCount );        
            }
        });
        
        t.start();
        
        
        
        
        
    }
}

结果如下

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 调用此方法。