面试官: 有了解过线程组和线程优先级吗

太过爱你忘了你带给我的痛 2023-09-29 16:30 16阅读 0赞

### 前言 ###

目前正在出一个`Java多线程专题`长期系列教程，从入门到进阶含`源码解读`, 篇幅会较多, 喜欢的话，给个关注

### 什么是线程组 ###

在Java中，线程组使用`ThreadGroup`表示，其中`Thread`存于线程组中，从字面意思也很好理解。在创建线程过程中，`Thread`不能独立于线程组之外,之前我们学习创建线程时，没有指定线程组，因为在默认情况下，它会将当前的线程环境作为线程组, 可以通过`Thread.currentThread().getThreadGroup()`获取线程组,线程组可以方便管理我们的线程，一定程度上提高了安全性

public class ThreadGroupTest {
        public static void main(String[] args) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getThreadGroup().getName());
            }).start();
            System.out.println(Thread.currentThread().getThreadGroup().getName());
        }
    }

输出:

main
    main

可以发现在`main`线程组下

`ThreadGroup`是一个标准的**「向下引用」**的树状结构，这样设计的原因是**「防止"上级"线程被"下级"线程引用而无法有效地被GC回收」**。

### 线程优先级 ###

线程的`优先级`级别由操作系统决定，不同的操作系统级别是不一样的，在Java中，提供了一个级别范围`1~10`,方便我们去参考。Java默认的线程优先级为`5`，线程的执行顺序由`调度程序`来决定，线程的优先级会在线程被`调用之前`设定。

#### 源码描述: ####

/**
         * 最低级别
         */
        public final static int MIN_PRIORITY = 1;
    
       /**
         * 默认级别
         */
        public final static int NORM_PRIORITY = 5;
    
        /**
         * 最高级别
         */
        public final static int MAX_PRIORITY = 10;

#### 获取线程优先级别 ####

public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("default level: {}" + Thread.currentThread().getPriority());
        }).start();
    }

输出: `default level: {}5`

#### 设置级别 ####

public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("default level: {}" + Thread.currentThread().getPriority());
        });
        t.start();
        t.setPriority(10);
    }

输出: `default level: {}10`

通常来讲，高级别的优先级往往会更高`几率`的执行，注意这里是概率性问题，下面我们测试一下

public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello " +  Thread.currentThread().getPriority());
            System.out.println("default level: {}" + Thread.currentThread().getPriority());
        });
        t.setPriority(3);
    
        Thread t1 = new Thread(() -> {
            System.out.println("hello " +  Thread.currentThread().getPriority());
            System.out.println("default level: {}" + Thread.currentThread().getPriority());
        });
        t1.setPriority(7);
    
        Thread t2 = new Thread(() -> {
            System.out.println("hello " +  Thread.currentThread().getPriority());
            System.out.println("default level: {}" + Thread.currentThread().getPriority());
        });
        t2.setPriority(10);
    
    
        t.start();
        t1.start();
        t2.start();
    }

第一次输出:

hello 7
    default level: {}7
    hello 10
    default level: {}10
    hello 3
    default level: {}3

第二次：

hello 3
    default level: {}3
    hello 7
    default level: {}7
    hello 10
    default level: {}10

第三次

hello 10
    default level: {}10
    hello 7
    default level: {}7
    hello 3
    default level: {}3

...

发现，不断的尝试之后，高级别出现的概率会比较靠前一点, 所以想要借助它来完成一些特定业务的同学注意了，不建议使用，`不靠谱`,之前也讲到，底层还是由操作系统调度完成

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

除了`主线程`之外，还有一个线程是`守护线程`,它的优先级比较低。如果所有的`非守护线程`都结束了，这个守护线程也会`自动结束`。可以借助它实现一些特定场景，比如手动关闭线程的场景,某些场景下不关闭，会造成资源浪费，手动关闭又很麻烦。这里我们可以通过`setDaemon(true)`指定

public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello " +  Thread.currentThread().getPriority());
            System.out.println("default level: {}" + Thread.currentThread().getPriority());
        });
        t.setDaemon(true); // 默认为false
        t.setPriority(10);
    
        Thread t1 = new Thread(() -> {
            System.out.println("hello " +  Thread.currentThread().getPriority());
            System.out.println("default level: {}" + Thread.currentThread().getPriority());
        });
        t1.setPriority(7);
    
        t.start();
        t1.start();
    }

输出:

hello 7
    default level: {}7
    hello 10
    default level: {}10

发现即使指定了高级别，执行的优先级仍然是最低的

### 线程组下的优先级 ###

刚刚我们都是在`main`线程组下，举一反三，线程组下的优先级又是怎么样的呢❓下面，测试一下

public static void main(String[] args) {
            // 指定 name 为 g1的线程组
            ThreadGroup group = new ThreadGroup("g1");
            group.setMaxPriority(4);
    
            Thread t = new Thread(group, () -> {
                System.out.println("hello " +  Thread.currentThread().getPriority());
                System.out.println("default level: {}" + Thread.currentThread().getPriority());
            }, "t0");
            t.setPriority(10);
            t.start();
        }

输出:

hello 4
    default level: {}4

发现，在`g1`线程组下指定了最大优先级后，线程`t0`的优先级最大级别只能是`4`, 所以这也是使用线程组的好处。

我们可以通过如下方式复制线程组, ThreadGroup提供了`enumerate`方法

public static void main(String[] args) throws InterruptedException {
            // 指定 name 为 g1的线程组
            ThreadGroup group = new ThreadGroup("g1");
            group.setMaxPriority(4);
    
            Thread t = new Thread(group, () -> {
                System.out.println("hello " +  Thread.currentThread().getPriority());
                System.out.println("default level: {}" + Thread.currentThread().getPriority());
            }, "t0");
            t.setPriority(10);
            t.start();
    
            // 复制线程组
            System.out.println(group.activeCount()); // 1
            Thread[] list = new Thread[group.activeCount()];
            group.enumerate(list);
    
            Thread.sleep(3000);
            System.out.println(list[0].getName()); // 输出 t0
    
        }

#### 统一异常捕获 ####

public static void main(String[] args) {
            // 指定 name 为 g1的线程组
            ThreadGroup group = new ThreadGroup("g1") {
                // 统一异常捕获
                public void uncaughtException(Thread t, Throwable e) {
                    System.out.println(t.getName() + ": " + e.getMessage()); // t0: 我出错了
                }
            };
            group.setMaxPriority(4);
    
            Thread t = new Thread(group, () -> {
                System.out.println("hello " +  Thread.currentThread().getPriority());
                System.out.println("default level: {}" + Thread.currentThread().getPriority());
                throw new RuntimeException("我出错了");
            }, "t0");
            t.setPriority(10);
            t.start();
        }

#### 向下引用的树状数据结构 ####

线程组的内部其实不单单可以放线程，其实也可以放其它线程组,我们看下源码定义

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[];

这里大家可以大胆去猜测一下，为什么要采用这种数据结构❓其实你通过源码发现，它的内部很多地方都调用了`checkAccess`方法，特别是在`set`操作,字面意思是检查是否有权限,我看下这个方法

public final void checkAccess() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkAccess(this);
        }
    }

它调用了一个`SecurityManager`, 它是Java的安全管理器，它允许应用程序在执行一个可能不安全或敏感的操作前确定该操作是什么，以及是否是在允许执行该操作的安全上下文中执行它。应用程序可以允许或不允许该操作。总的来说就是保证安全性。

通过上面的了解，我们应该知道为什么要用这种树状结构了。它都是一层一层级别的控制，这么做方便去管理，提高安全性，出了问题也能很快的定位到。就像公司的人员组织架构一样，一切都是为了管理好公司。

### 结束语 ###

本篇内容到这里就结束了, 大家自己一定要多去理解，不要去背，下期给大家讲讲线程的`状态`以及它的生命周期~

关注关注，主页更多java内容

![2b68be50f7134844a13ab8e50bae19c2.jpeg][]

[2b68be50f7134844a13ab8e50bae19c2.jpeg]: https://img-blog.csdnimg.cn/2b68be50f7134844a13ab8e50bae19c2.jpeg