线程组ThreadGroup

1、线程组简介

在Java中，线程组是指java.lang.ThreadGroup类的对象，每个线程都隶属于唯一的一个线程组，这个线程组在线程创建时指定并在线程的整个生命周期内都不能更改。可以通过调用包含ThreadGroup类型参数的Thread类构造方法来指定线程所属线程组。若没有指定，则线程默认的隶属于名为main的系统线程组。除了预建的系统线程外，所以线程组都必须显式创建。

  在java中除系统线程外的每个线程组又隶属于另一个线程组，可以在创建线程组时指定其所隶属的线程组，若没有指定，则默认地隶属于系统线程组。这样，所以线程组组成了一棵以系统线程组为根的树。

2、线程组构造函数

在Thread类里面也提供了几个引入ThreadGroup的构造方法。

Thread(ThreadGroup group, Runnable target)           分配新的 Thread 对象。

Thread(ThreadGroup group, Runnable target, String name)           分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，并作为 group 所引用的线程组的一员。

Thread(ThreadGroup group, Runnable target, String name, long stackSize)           分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，作为 group 所引用的线程组的一员，并具有指定的堆栈大小。

Thread(ThreadGroup group, String name)           分配新的 Thread 对象。

3、ThradGroup方法

对ThreadGroup类的常用方法说明如下：

方法摘要 

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

4、代码实例

package com.xxx.util;

/**
 * Created with IntelliJ IDEA.
 * Date: 15-4-9
 * Time: 上午9:04
 * To change this template use File | Settings | File Templates.
 */
public class Result {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.xxx.util;

import java.util.Date;
import java.util.Random;
import java.util.concurrent.TimeUnit;

/**
 * Created with IntelliJ IDEA.
 * Date: 15-4-9
 * Time: 上午9:04
 * To change this template use File | Settings | File Templates.
 */
public class ThreadGroupSearch implements Runnable {

    private Result result;

    public ThreadGroupSearch(Result result) {
        this.result = result;
    }

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.printf("Thread %s: Start\n",name);
        try {
            doTask();
            result.setName(name);
        } catch (Exception e) {
            System.out.printf("Thread %s: interrupted\n",name);
            return;
        }
    }

    private void doTask() throws Exception{
        Random random = new Random(new Date().getTime());
        int value = (int)(random.nextDouble()*100);
        System.out.printf("Thread %s:%d\n",Thread.currentThread().getName(),value);
        TimeUnit.SECONDS.sleep(value);
    }

}

package com.xxx.util;

import java.util.concurrent.TimeUnit;

/**
 * Created with IntelliJ IDEA.
 * Date: 15-4-9
 * Time: 上午9:16
 * To change this template use File | Settings | File Templates.
 */
public class ThreadGroupSearchMain {

    public static void main(String[] args){
        ThreadGroup threadGroup = new ThreadGroup("searchGroup");
        Result result = new Result();
        ThreadGroupSearch threadGroupSearch = new ThreadGroupSearch(result);
        for(int i=0;i<10;i++){
            Thread thread = new Thread(threadGroup,threadGroupSearch);
            thread.start();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //threadGroup.activeCount()获取线程组线程数目
        System.out.printf("Number of Threads:%d\n",threadGroup.activeCount());
        System.out.printf("Information about the Thread Group\n");
        //打印线程组对象的信息
        threadGroup.list();
        Thread[] threads = new Thread[threadGroup.activeCount()];
        threadGroup.enumerate(threads);
        for(int i=0;i<threadGroup.activeCount();i++){
            System.out.printf("Thread %s:%s\n",threads[i].getName(),threads[i].getState());
        }
        waitFinish(threadGroup);
        threadGroup.interrupt();
    }

    private static  void waitFinish(ThreadGroup threadGroup){
        while (threadGroup.activeCount()>9){
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

5、运行结果

6、结论

线程组类存储了线程对象和关联的线程组对象，并可以访问它们的信息（例如状态），将执行操作应用到所有成员上（例如中断）。