Java并发编程之ThreadGroup

ThreadGroup是Java提供的一种对线程进行分组管理的手段，可以对所有线程以组为单位进行操作，如设置优先级、守护线程等。

线程组也有父子的概念，如下图：

线程组的创建

public class ThreadGroupCreator {

    public static void main(String[] args) {
        //获取当前线程的group
        ThreadGroup currentGroup = Thread.currentThread().getThreadGroup();
        //在当前线程执行流中新建一个Group1
        ThreadGroup group1 = new ThreadGroup("Group1");
        //Group1的父线程,就是main线程所在Group
        System.out.println(group1.getParent() == currentGroup);
        //定义Group2, 指定group1为其父线程
        ThreadGroup group2 = new ThreadGroup(group1, "Group2");
        System.out.println(group2.getParent() == group1);
    }
}

线程组的基本操作

注意：后添加进线程组的线程，其优先级不能大于线程组的优先级

public class ThreadGroupBasic {

    public static void main(String[] args) throws InterruptedException {
        
        ThreadGroup group = new ThreadGroup("group1");
        Thread thread = new Thread(group, () -> {
            while(true) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "thread");
        thread.setDaemon(true);
        thread.start();
        
        TimeUnit.MILLISECONDS.sleep(1);
        
        ThreadGroup mainGroup = Thread.currentThread().getThreadGroup();
        //递归获取mainGroup中活跃线程的估计值
        System.out.println("activeCount = " + mainGroup.activeCount());
        //递归获mainGroup中的活跃子group
        System.out.println("activeGroupCount = " + mainGroup.activeGroupCount());
        //获取group的优先级, 默认为10
        System.out.println("getMaxPriority = " + mainGroup.getMaxPriority());
        //获取group的名字
        System.out.println("getName = " + mainGroup.getName());
        //获取group的父group, 如不存在则返回null
        System.out.println("getParent = " + mainGroup.getParent());
        //活跃线程信息全部输出到控制台
        mainGroup.list();
        System.out.println("----------------------------");
        //判断当前group是不是给定group的父线程, 如果两者一样,也会返回true
        System.out.println("parentOf = " + mainGroup.parentOf(group));
        System.out.println("parentOf = " + mainGroup.parentOf(mainGroup));

    }

}

线程组的Interrupt

ublic class ThreadGroupInterrupt {

    public static void main(String[] args) throws InterruptedException {
        ThreadGroup group = new ThreadGroup("TestGroup");
        new Thread(group, () -> {
            while(true) {
                try {
                    TimeUnit.MILLISECONDS.sleep(2);
                } catch (InterruptedException e) {
                    //received interrupt signal and clear quickly
                    System.out.println(Thread.currentThread().isInterrupted());
                    break;
                }
            }
            System.out.println("t1 will exit");
        }, "t1").start();
        new Thread(group, () -> {
            while(true) {
                try {
                    TimeUnit.MILLISECONDS.sleep(2);
                } catch (InterruptedException e) {
                    //received interrupt signal and clear quickly
                    System.out.println(Thread.currentThread().isInterrupted());
                    break;
                }
            }
            System.out.println("t2 will exit");
        }, "t2").start();
        //make sure all threads start
        TimeUnit.MILLISECONDS.sleep(2);
        
        group.interrupt();
    }

}

线程组的destroy

public class ThreadGroupDestroy {

    public static void main(String[] args) {
        ThreadGroup group = new ThreadGroup("TestGroup");
        ThreadGroup mainGroup = Thread.currentThread().getThreadGroup();
        //before destroy
        System.out.println("group.isDestroyed=" + group.isDestroyed());
        mainGroup.list();
        
        group.destroy();
        //after destroy
        System.out.println("group.isDestroyed=" + group.isDestroyed());
        mainGroup.list();
    }

}

线程组设置守护线程组

线程组设置为守护线程组，并不会影响其线程是否为守护线程，仅仅表示当它内部没有active的线程的时候，会自动destroy

public class ThreadGroupDaemon {

    public static void main(String[] args) throws InterruptedException {
        ThreadGroup group1 = new ThreadGroup("group1");
        new Thread(group1, () -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "group1-thread1").start();
        ThreadGroup group2 = new ThreadGroup("group2");
        new Thread(group2, () -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "group1-thread2").start();
        group2.setDaemon(true);
        
        TimeUnit.SECONDS.sleep(3);
        System.out.println(group1.isDestroyed());
        System.out.println(group2.isDestroyed());
    }
}