一宿君

V1

2022/08/06阅读:18主题:默认主题

Java并发编程系列(二)线程组、线程优先级以及守护线程

本期内容包含以下几点:

  • 线程组(ThreadGroup)
  • 线程的优先级
  • 守护线程(Daemon)
  • 线程组的常用法
  • 线程组的数据结构

上期文章:Java并发编程系列(一)进程与线程的概念

线程组(ThreadGroup)

Java中用ThreadGroup来表示线程组,我们可以使用线程组对线程进行批量控制。

ThreadGroup和Thread的关系就如同他们的字面意思一样简单粗暴,每个Thread必然存在于一个ThreadGroup中,Thread不能独立于ThreadGroup存在。执行main()方法线程的名字是main,如果在new Thread()时没有显式指定线程名字,那么默认将父线程(当前包含并执行new Thread()的线程)线程组设置为自己的线程组。

示例代码:

public class ThreadGroupDemo {

    public static void main(String[] args) {
        //testThread示例
        Thread testThread = new Thread(() -> {
            System.out.println("testThread当前线程组名字:" + Thread.currentThread().getThreadGroup().getName());
            System.out.println("testThread当前线程名字:" + Thread.currentThread().getName());
        });
        //执行
        testThread.start();

        //执行当前main方法
        System.out.println("执行main当前线程组名字:" + Thread.currentThread().getThreadGroup().getName());
        System.out.println("执行main当前线程名字:" + Thread.currentThread().getName());
    }

}

输出结果:

执行main当前线程组名字:main
执行main当前线程名字:main
testThread当前线程组名字:main
testThread当前线程名字:Thread-0

每个ThreadGroup管理着它包含的Thread,ThreadGroup是一个标准的向下引用的树状结构,这样设计的原因是防止"上级"线程被"下级"线程引用而无法有效地被GC回收

线程的优先级

现代操作系统基本采用时分的形式调度运行的线程,操作系统会分出一个个时间片,线程会分配到若干个时间片,当线程的时间片用完了就会发生线程调度,并等待下次分配。线程分配时间片的多少决定了线程占用处理器资源的时长,而线程优先级就是决定线程需要多分配或者少分配处理资源的一个线程属性。

在Java中,有一个整型的成员变量priority来控制优先级,优先级的范围从1~10,在线程构建的时候,可以通过setPriority(int)方法来修改优先级,不设置默认优先级为5,通常情况下,优先级高的线程分配时间片的数量要多于优先级低的线程。

Java中线程优先级可以指定,范围是1~10。但是并不是所有的操作系统都支持10级优先级的划分(比如有些操作系统只支持3级划分:低,中,高),Java只是给操作系统一个优先级的参考值,线程最终在操作系统的优先级是多少还是由操作系统决定。

Java默认的线程优先级为5,线程的执行顺序由调度程序来决定,线程的优先级会在线程被调用之前设定。

通常情况下,高优先级的线程将会比低优先级的线程有更高的几率得到执行。我们使用方法Thread类的setPriority()实例方法来设定线程的优先级。

public class Demo {
    public static void main(String[] args) {
        Thread a = new Thread();
        System.out.println("默认线程优先级:"+a.getPriority());
        Thread b = new Thread();
        b.setPriority(10);
        System.out.println("设置过的线程优先级:"+b.getPriority());
    }
}

输出结果:

默认线程优先级:5
设置过的线程优先级:10

既然有1-10的级别来设定了线程的优先级,这时候可能有些读者会问,那么我是不是可以在业务实现的时候,采用这种方法来指定一些线程执行的先后顺序?

对于这个问题,答案是:No!

Java中的优先级来说不是特别的可靠,Java程序中对线程所设置的优先级只是给操作系统一个建议,操作系统不一定会采纳。而真正的调用顺序,是由操作系统的线程调度算法决定的

实例代码:

public class PriorityDemo {

    public static void main(String[] args) {
        IntStream.range(1,10).forEach(i -> {
            Thread thread = new Thread(new TestThread(i));
            thread.setPriority(i);
            thread.start();
        });

    }

    public static class TestThread extends Thread {
        private int i;

        public TestThread(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            super.run();
            System.out.println(String.format( "第" + i + "轮,当前执行的线程是:%s,优先级为:%d",Thread.currentThread().getName(),Thread.currentThread().getPriority()));
        }
    }

}

输出结果(每次输出的结果不一定相同):

9轮,当前执行的线程是:Thread-17,优先级为:9
6轮,当前执行的线程是:Thread-11,优先级为:6
7轮,当前执行的线程是:Thread-13,优先级为:7
5轮,当前执行的线程是:Thread-9,优先级为:5
8轮,当前执行的线程是:Thread-15,优先级为:8
4轮,当前执行的线程是:Thread-7,优先级为:4
3轮,当前执行的线程是:Thread-5,优先级为:3
2轮,当前执行的线程是:Thread-3,优先级为:2
1轮,当前执行的线程是:Thread-1,优先级为:1

从上述输出结果可以看出线程优先级并没有生效,这表示Java程序的正确性以及顺序性并不能依赖线程的优先级高低,因为操作系统可以完全不用理会Java线程的对于优先级的决定。

Java提供一个线程调度器来监视和控制处于RUNNABLE状态的线程。线程的调度策略采用抢占式注意:优先级高的线程比优先级低的线程只是会有更大的几率优先执行,而不是绝对的。在优先级相同的情况下,按照“先到先得”的原则。每个Java程序都有一个默认的主线程,就是通过JVM启动的第一个线程main线程。

在之前,我们有谈到一个线程必然存在于一个线程组中,那么当线程和线程组的优先级不一致的时候将会怎样呢?

示例代码:

public static void main(String[] args) {
    ThreadGroup threadGroup = new ThreadGroup("t1");
    threadGroup.setMaxPriority(6);
    Thread thread = new Thread(threadGroup,"thread");
    thread.setPriority(9);//5
    System.out.println("我是线程组的优先级"+threadGroup.getMaxPriority());
    System.out.println("我是线程的优先级"+thread.getPriority());//5(不大于线程组的最大优先级的情况采用本身的优先级)
}

输出结果:

我是线程组的优先级6
我是线程的优先级6

所以,如果某个线程优先级大于所在线程组的最大优先级,那么该线程的优先级将会失效,取而代之的是线程组的最大优先级,如果不大于所在线程组的最大优先级,则仍然采用本身的优先级。

守护线程(Daemon)

守护线程是一种支持型线程,它主要被用作后台调度以及支持性工作。

当一个Java虚拟机中不存在非守护线程的时候,Java虚拟机将会退出。

线程默认为非守护线程,可以通过Thread.setDaemon(true)将线程设置为守护线程,Daemon属性需要在启动线程之前设置,不能在启动之后设置。

示例代码:

public class DaemonThreadDemo {

    public static void main(String[] args) {
        Thread thread = new Thread(new DaemonThread(),"DaemonThread");
        thread.setDaemon(true);//设置为守护进程
        thread.start();
    }

    static class DaemonThread implements Runnable {

        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println("DaemonThread finally run.");
            }
        }
    }
}

可以看到终端或者命令提示符界面没有任何输出,main线程(是非守护线程)在启动了DaemonThread线程之后随着main方法的执行结束而终止,而此时Java虚拟机中已经没有非守护线程了,所以Java虚拟机需要退出,同时Java虚拟机中所有的线程都要立即终止,因此DaemonThread守护线程直接终止,finally代码块中的语句并没有执行。

在构建守护线程时,不能依靠finally块中的内容来确保执行关闭或清理资源的逻辑。

结论:

如果某线程是守护线程,那当其他所有的非守护线程都结束了,这个守护线程也会自动结束。

应用场景是:当所有非守护线程结束时,其余的子线程(守护线程)自动关闭,就免去了还要继续关闭子线程的麻烦。

线程组的常用方法及数据结构

线程组的常用方法

获取当前的线程组名字

Thread.currentThread().getThreadGroup().getName()

复制线程组

// 获取当前的线程组
ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
// 复制一个线程组到一个线程数组(获取Thread信息)
Thread[] threads = new Thread[threadGroup.activeCount()];
threadGroup.enumerate(threads);

线程组统一异常处理

public class ThreadGroupDemo {

    public static void main(String[] args) {
        ThreadGroup threadGroup = new ThreadGroup("group1"){
            /**
             * 在线程成员抛出unchecked exception异常时,会执行此方法
             * @param t
             * @param e
             */

            @Override
            public void uncaughtException(Thread t, Throwable e) {
                super.uncaughtException(t, e);
                System.out.println(t.getName() + ":" + e.getMessage());
            }
        };

        //这个线程是ThreadGroup的一员
        Thread thread1 = new Thread(threadGroup, new Runnable() {
            @Override
            public void run() {
                //抛出unchenked异常
                throw new RuntimeException("测试异常!");
            }
        });
        thread1.start();
    }
}

输出结果:

Exception in thread "Thread-0" java.lang.RuntimeException: 测试异常!
 at com.wbs.anightmonarch.concurrent.ThreadGroupDemo$2.run(ThreadGroupDemo.java:46)
 at java.lang.Thread.run(Thread.java:748)
Thread-0:测试异常!

线程组的数据结构

线程组还可以包含其他的线程组,不仅仅是线程。

首先看看 ThreadGroup源码中的成员变量:

public class ThreadGroup implements Thread.UncaughtExceptionHandler {
    private final ThreadGroup parent;//父级线程组
    String name;//当前线程组名称
    int maxPriority;//最大优先级
    boolean destroyed;//是否被销毁
    boolean daemon;//是否为守护线程
    boolean vmAllowSuspension;//是否可以中断

    int nUnstartedThreads = 0;//还未启动的线程
    int nthreads;//当前线程组中的线程数目
    Thread threads[];//当前线程组中的所有线程

    int ngroups;//线程组数目
    ThreadGroup groups[];//当前线程组中包含的线程组
}

构造函数:

//创建一个不在任何线程组中的空线程组,该方法用于创建系统线程组(私有构造函数)
private ThreadGroup() {
    this.name = "system";
    this.maxPriority = Thread.MAX_PRIORITY;
    this.parent = null;
}
// 默认是以当前ThreadGroup传入作为parent ThreadGroup,新线程组的父线程组是目前正在运行线程的线程组。
public ThreadGroup(String name) {
     this(Thread.currentThread().getThreadGroup(), name);
}

//构造函数
public ThreadGroup(ThreadGroup parent, String name) {
        this(checkParentAccess(parent), parent, name);
}

//私有构造函数,主要的构造函数
private ThreadGroup(Void unused, ThreadGroup parent, String name) {
        this.name = name;
        this.maxPriority = parent.maxPriority;
        this.daemon = parent.daemon;
        this.vmAllowSuspension = parent.vmAllowSuspension;
        this.parent = parent;
        parent.add(this);
}

第三个构造函数里调用了checkParentAccess方法,这里看看这个方法的源码:

// 检查parent ThreadGroup
private static Void checkParentAccess(ThreadGroup parent) {
    parent.checkAccess();
    return null;
}

// 判断当前运行的线程是否具有修改线程组的权限
public final void checkAccess() {
    SecurityManager security = System.getSecurityManager();
    if (security != null) {
        security.checkAccess(this);
    }
}

这里涉及到SecurityManager这个类,它是Java的安全管理器,它允许应用程序在执行一个可能不安全或敏感的操作前确定该操作是什么,以及是否在允许执行该操作的安全上下文中执行它。应用程序可以允许或不允许该操作。

比如引入了第三方类库,但是并不能保证它的安全性。

其实Thread类也有一个checkAccess()方法,不过是用来检测当前运行的线程是否有权限修改被调用的这个线程实例。(Determines if the currently running thread has permission to modify this thread.)

总结来说,线程组是一个树状的结构,每个线程组下面可以有多个线程或者线程组。线程组可以起到统一控制线程的优先级和检查线程的权限的作用。


内容总结来源以下文章:
专注于Java基础、进阶、面试以及计算机基础知识分享🐳。偶尔认知思考、日常水文🐌。
公众号二维码
公众号二维码
随和的皮蛋桑
随和的皮蛋桑

分类:

后端

标签:

后端

作者介绍

一宿君
V1

Java开发工程师