Java线程组

类似于在计算机中使用文件夹管理文件,也可以使用线程组来管理线程，在线程组中定义一组相似(相关)的线程，在线程组中也可以定义子线程组。

Thread类有几个构造方法允许在创建线程时指定线程组,如果在创建线程时没有指定线程组则该线程就属于父线程所在的线程组，JVM在创建main线程时会为它指定一个线程组,因此每个Java线程都有一个线程组与之关联, 可以调用线程的getThreadGroup()方法返回线程组。

线程组开始是出于安全的考虑设计用来区分不同的Applet，然而ThreadGroup并未实现这一目标,在新开发的系统中，已经不常用线程组，现在一般会将一组相关的线程存入一个数组或一个集合中，如果仅仅是用来区分线程时,可以使用线程名称来区分，多数情况下,可以忽略线程组。

Java创建线程组

package com.wkcto.threadgroup;

/**
 * 演示创建线程组
 */
public class Test01 {
    public static void main(String[] args) {
        // 1) 返回当前main线程的线程组
        ThreadGroup mainGroup = Thread.currentThread().getThreadGroup();
        System.out.println(mainGroup);

        //2) 定义线程组,如果不指定所属线程组,则自动归属当前线程所属的线程组中
        ThreadGroup group1 = new ThreadGroup("group1");
        System.out.println(group1);

        //3)定义线程组, 同时指定父线程组
        ThreadGroup group2 = new ThreadGroup(mainGroup, "group2");
        //现在group1与group2都是maingroup线程组中的子线程组, 调用线程组的getParent()方法返回父线程组
        System.out.println( group1.getParent() == mainGroup);       //true
        System.out.println( group2.getParent() == mainGroup);

        //4) 在创建线程时指定所属线程组
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread());
            }
        };
        //在创建线程时,如果没有指定线程组,则默认线程归属到父线程的线程组中
        //在main线程中创建了t1线程,称main线程为父线程,t1线程为子线程, t1没有指定线程组则t1线程就归属到父线程main线程的线程组中
        Thread t1 = new Thread(r, "t1");
        System.out.println( t1 );   //Thread[t1,5,main], t1的线程组是main线程组
        //创建线程时,可以指定线程所属线程组
        Thread t2 = new Thread(group1, r, "t2");
        Thread t3 = new Thread(group2, r, "t3");
        System.out.println(t2);
        System.out.println(t3);
    }
}

Java线程组的基本操作

activeCount() 返回当前线程组及子线程组中活动线程的数量(近似值)。

activeGroupCount() 返回当前线程组及子线程组中活动线程组的数量(近似值)。

int enumerate(Thread[] list) 将当前线程组中的活动线程复制到参数数组中。

enumerate(ThreadGroup[] list) 将当前线程组中的活动线程组复制到参数数组中。

getMaxPriority() 返回线程组的最大优先级,默认是10。

getName() 返回线程组的名称。

getParent() 返回父线程组。

interrupt() 中断线程组中所有的线程。

isDaemon() 判断当前线程组是否为守护线程组。

list() 将当前线程组中的活动线程打印出来。

parentOf(ThreadGroup g) 判断当前线程组是否为参数线程组的父线程组。

setDaemon(boolean daemon) 设置线程组为守护线程组。

package com.wkcto.threadgroup;

/**
 * 演示线程组的基本操作
 */
public class Test02 {
    public static void main(String[] args) {
        ThreadGroup mainGroup = Thread.currentThread().getThreadGroup();    //返回当前线程组
        //再定义线程组
        ThreadGroup group = new ThreadGroup("group");  //默认group的父线程组是main线程组

        Runnable r = new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println("-----------当前线程: " + Thread.currentThread());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Thread t1 = new Thread(r, "t1");        //默认在main线程组中创建线程
        Thread t2 = new Thread(group, r, "t2");     //在指定的group线程组中创建线程
        t1.start();
        t2.start();

        //打印线程组的相关属性
        System.out.println("main 线程组中活动线程数量: " + mainGroup.activeCount());  //4, main线程组中活动线程: main, t1, t2, 垃圾回收器
        System.out.println("group 子线程组中活动线程数量: " + group.activeCount());    //1,  t2
        System.out.println("main线程组中子线程组数量: " + mainGroup.activeGroupCount());  //1,  group
        System.out.println("group子线程组中子线程组数量: " + group.activeGroupCount());    //0
        System.out.println("main线程组的父线程组: " + mainGroup.getParent());   //main线程组的父线程组是system
        System.out.println("group线程组的父线程组: " + group.getParent());  //main
        System.out.println( mainGroup.parentOf(mainGroup));  //true, 线程组也是它自己的父线程组
        System.out.println( mainGroup.parentOf(group));     //true
        mainGroup.list();   //把main线程组中所有的线程打印输出
    }
}

复制线程组中的线程及子线程组

enumerate(Thread[] list) 把当前线程组和子线程组中所有的线程复制到参数数组中。

enumerate(Thread[] list, boolean recursive) , 如果第二个参数设置为false,则只复制当前线程组中所有的线程,不复制子线程组中的线程。

enumerate(ThreadGroup[] list) 把当前线程组和子线程组中所有的线程组复制到参数数组中。

enumerate(ThreadGroup[] list, boolean recurse) 第二个参数设置false,则只复制当前线程组的子线程组。

package com.wkcto.threadgroup;

/**
 * 演示复制线程组中的内容
 */
public class Test03 {
    public static void main(String[] args) {
        ThreadGroup mainGroup = Thread.currentThread().getThreadGroup();    //返回main线程的main线程组

        //main线程组中定义了两个子线程组
        ThreadGroup group1 = new ThreadGroup("group1");     //默认group1的父线程组就是当前线程组main
        ThreadGroup group2 = new ThreadGroup(mainGroup, "group2");

        Runnable r = new Runnable() {
            @Override
            public void run() {
                while (true){
                    System.out.println("----当前线程: " + Thread.currentThread());
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        //创建并启动三个线程
        Thread t1 = new Thread(r, "t1");    //默认在main线程组中创建线程
        Thread t2 = new Thread(group1, r, "t2");    //在group1线程组中创建线程
        Thread t3 = new Thread(group2, r, "t3");    //在group2线程组中创建线程
        t1.start();
        t2.start();
        t3.start();

        //1) 把main线程组中的线程复制到数组中
        //先定义存储线程的数组,数组的长度为main线程组中活动线程的数量
        Thread[] threadList = new Thread[mainGroup.activeCount()];
 /*       //把main线程组包括子线程组中的所有的线程复制到数组中
        mainGroup.enumerate(threadList);
        //遍历threadList数组
        for (Thread thread : threadList) {
            System.out.println(thread);
        }
        System.out.println("----------------------------");*/

        //只把main线程组中的线程复制到数组中,不包含子线程组的线程
        mainGroup.enumerate(threadList, false);
        //遍历threadList数组
        for (Thread thread : threadList) {
            System.out.println(thread);
        }
        System.out.println("----------------------------");

        //2) 把main线程组中的子线程组复制到数组中
        //定义数组存储线程组
        ThreadGroup [] threadGroups = new ThreadGroup[mainGroup.activeGroupCount()];
        //把main线程组中的子线程组复制到数组中
        mainGroup.enumerate(threadGroups);
        System.out.println("============================");
        for (ThreadGroup threadGroup : threadGroups) {
            System.out.println(threadGroup);
        }
    }
}

线程组的批量中断

线程组的interrupt() 可以给该线程组中所有的活动线程添加中断标志。

package com.wkcto.threadgroup;

/**
 * 线程组的批量中断
 */
public class Test04 {
    public static void main(String[] args) throws InterruptedException {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程--" + Thread.currentThread() + "--开始循环");
                //当线程没有被中断就一直循环
                while ( !Thread.currentThread().isInterrupted()){
                    System.out.println(Thread.currentThread().getName() + "------------------");
                  /*  try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        //如果中断睡眠中的线程,产生中断异常, 同时会清除中断标志
                        e.printStackTrace();
                    }*/
                }
                System.out.println(Thread.currentThread().getName() + "循环结束");
            }
        };

        //创建线程组
        ThreadGroup group = new ThreadGroup("group");

        //在group线程组中创建5个线程
        for (int i = 0; i < 5; i++) {
            new Thread(group,r).start();
        }

        //main线程睡眠2秒
        Thread.sleep(50);
        //中断线程组, 会中断线程组中所有的线程
        group.interrupt();
    }
}

设置守护线程组

守护线程是为其他线程提供服务的,当JVM中只有守护线程时,守护线程会自动销毁,JVM会退出。

调用线程组的setDaemon(true)可以把线程组设置为守护线程组,当守护线程组中没有任何活动线程时,守护线程组会自动销毁。

注意线程组的守护属性,不影响线程组中线程的守护属性,或者说守护线程组中的线程可以是非守护线程。

package com.wkcto.threadgroup;

/**
 * 演示设置守护线程组
 */
public class Test05 {
    public static void main(String[] args) throws InterruptedException {
        //先定义线程组
        ThreadGroup group = new ThreadGroup("group");

        //设置线程组为守护线程组
        group.setDaemon(true);

        //向组中添加3个线程
        for (int i = 0; i < 3; i++) {
            new Thread(group, new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 20; j++) {
                        System.out.println(Thread.currentThread().getName() + " -- " + j);
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        }

        //main线程睡眠5秒
        Thread.sleep(5000);
        System.out.println("main...end....");
    }
}

Java多线程：newCondition()方法 Java多线程捕获异常处理

全部教程

Java线程组

Java创建线程组

视频课程

2020Java零基础教程

AJAX视频教程全集

linux基础视频教程