第三章 线程组和线程优先级

3.1 线程组(ThreadGroup)

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

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

示例代码：

  1. public class Demo {
  2.     public static void main(String[] args) {
  3.         Thread testThread = new Thread(() -> {
  4.             System.out.println("testThread当前线程组名字：" +
  5.                     Thread.currentThread().getThreadGroup().getName());
  6.             System.out.println("testThread线程名字：" +
  7.                     Thread.currentThread().getName());
  8.         });
  10.         testThread.start();
  11.     System.out.println("执行main所在线程的线程组名字： " + Thread.currentThread().getThreadGroup().getName());
  12.         System.out.println("执行main方法线程名字：" + Thread.currentThread().getName());
  13.     }
  14. }

输出结果：

  1. 执行main所在线程的线程组名字： main
  2. 执行main方法线程名字：main
  3. testThread当前线程组名字：main
  4. testThread线程名字：Thread-0

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

3.2 线程的优先级

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

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

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

  1. public class Demo {
  2.     public static void main(String[] args) {
  3.         Thread a = new Thread();
  4.         System.out.println("我是默认线程优先级："+a.getPriority());
  5.         Thread b = new Thread();
  6.         b.setPriority(10);
  7.         System.out.println("我是设置过的线程优先级："+b.getPriority());
  8.     }
  9. }

输出结果：

  1. 我是默认线程优先级：5
  2. 我是设置过的线程优先级：10

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

对于这个问题，我们的答案是:No!

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

我们通过代码来验证一下：

  1. public class Demo {
  2.     public static class T1 extends Thread {
  3.         @Override
  4.         public void run() {
  5.             super.run();
  6.             System.out.println(String.format("当前执行的线程是：%s，优先级：%d",
  7.                     Thread.currentThread().getName(),
  8.                     Thread.currentThread().getPriority()));
  9.         }
  10.     }
  12.     public static void main(String[] args) {
  13.         IntStream.range(1, 10).forEach(i -> {
  14.             Thread thread = new Thread(new T1());
  15.             thread.setPriority(i);
  16.             thread.start();
  17.         });
  18.     }
  19. }

某次输出：

  1. 当前执行的线程是：Thread-17，优先级：9
  2. 当前执行的线程是：Thread-1，优先级：1
  3. 当前执行的线程是：Thread-13，优先级：7
  4. 当前执行的线程是：Thread-11，优先级：6
  5. 当前执行的线程是：Thread-15，优先级：8
  6. 当前执行的线程是：Thread-7，优先级：4
  7. 当前执行的线程是：Thread-9，优先级：5
  8. 当前执行的线程是：Thread-3，优先级：2
  9. 当前执行的线程是：Thread-5，优先级：3

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

还有一种线程称为守护线程（Daemon），守护线程默认的优先级比较低。

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

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

一个线程默认是非守护线程，可以通过Thread类的setDaemon(boolean on)来设置。

在之前，我们有谈到一个线程必然存在于一个线程组中，那么当线程和线程组的优先级不一致的时候将会怎样呢？我们用下面的案例来验证一下：

  1. public static void main(String[] args) {
  2.     ThreadGroup threadGroup = new ThreadGroup("t1");
  3.     threadGroup.setMaxPriority(6);
  4.     Thread thread = new Thread(threadGroup,"thread");
  5.     thread.setPriority(9);
  6.     System.out.println("我是线程组的优先级"+threadGroup.getMaxPriority());
  7.     System.out.println("我是线程的优先级"+thread.getPriority());
  8. }

输出：

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

所以，如果某个线程优先级大于线程所在线程组的最大优先级，那么该线程的优先级将会失效，取而代之的是线程组的最大优先级。

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

3.3.1 线程组的常用方法

获取当前的线程组名字

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

复制线程组

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

线程组统一异常处理

  1. package com.func.axc.threadgroup;
  3. public class ThreadGroupDemo {
  4.     public static void main(String[] args) {
  5.         ThreadGroup threadGroup1 = new ThreadGroup("group1") {
  6.             // 继承ThreadGroup并重新定义以下方法
  7.             // 在线程成员抛出unchecked exception
  8.             // 会执行此方法
  9.             public void uncaughtException(Thread t, Throwable e) {
  10.                 System.out.println(t.getName() + ": " + e.getMessage());
  11.             }
  12.         };
  14.         // 这个线程是threadGroup1的一员
  15.         Thread thread1 = new Thread(threadGroup1, new Runnable() {
  16.             public void run() {
  17.                 // 抛出unchecked异常
  18.                 throw new RuntimeException("测试异常");
  19.             }
  20.         });
  22.         thread1.start();
  23.     }
  24. }

3.3.2 线程组的数据结构

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

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

  1. public class ThreadGroup implements Thread.UncaughtExceptionHandler {
  2.     private final ThreadGroup parent; // 父亲ThreadGroup
  3.     String name; // ThreadGroupr 的名称
  4.     int maxPriority; // 线程最大优先级
  5.     boolean destroyed; // 是否被销毁
  6.     boolean daemon; // 是否守护线程
  7.     boolean vmAllowSuspension; // 是否可以中断
  9.     int nUnstartedThreads = 0; // 还未启动的线程
  10.     int nthreads; // ThreadGroup中线程数目
  11.     Thread threads[]; // ThreadGroup中的线程
  13.     int ngroups; // 线程组数目
  14.     ThreadGroup groups[]; // 线程组数组
  15. }

然后看看构造函数：

  1. // 私有构造函数
  2. private ThreadGroup() { 
  3.     this.name = "system";
  4.     this.maxPriority = Thread.MAX_PRIORITY;
  5.     this.parent = null;
  6. }
  8. // 默认是以当前ThreadGroup传入作为parent  ThreadGroup，新线程组的父线程组是目前正在运行线程的线程组。
  9. public ThreadGroup(String name) {
  10.     this(Thread.currentThread().getThreadGroup(), name);
  11. }
  13. // 构造函数
  14. public ThreadGroup(ThreadGroup parent, String name) {
  15.     this(checkParentAccess(parent), parent, name);
  16. }
  18. // 私有构造函数，主要的构造函数
  19. private ThreadGroup(Void unused, ThreadGroup parent, String name) {
  20.     this.name = name;
  21.     this.maxPriority = parent.maxPriority;
  22.     this.daemon = parent.daemon;
  23.     this.vmAllowSuspension = parent.vmAllowSuspension;
  24.     this.parent = parent;
  25.     parent.add(this);
  26. }

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

  1. // 检查parent ThreadGroup
  2. private static Void checkParentAccess(ThreadGroup parent) {
  3.     parent.checkAccess();
  4.     return null;
  5. }
  7. // 判断当前运行的线程是否具有修改线程组的权限
  8. public final void checkAccess() {
  9.     SecurityManager security = System.getSecurityManager();
  10.     if (security != null) {
  11.         security.checkAccess(this);
  12.     }
  13. }

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

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

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

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

参考资料