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

转载声明

• 深入浅出多线程 - 第三章 - GitHub (opens new window)
• 守护线程(Daemon Thread) (opens new window)

一、线程组

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

每个 Thread 必然存在于一个 ThreadGroup 中，Thread 不能独立于 ThreadGroup 存在。 执行 main() 方法线程的名字是 main，如果在 new Thread 时没有显式指定，那么默认将父线程（当前执行 new Thread 的线程）线程组设置为自己的线程组。

public class Demo {
    public static void main(String[] args) {
        Thread testThread = new Thread(() -> {
            System.out.println("testThread当前线程组名字：" +
                               Thread.currentThread().getThreadGroup().getName());
            System.out.println("testThread线程名字：" +
                               Thread.currentThread().getName());
        });

        testThread.start();
        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 中线程优先级可以指定，范围是 1~10（数字越大优先级越高）。但是并不是所有的操作系统都支持 10 级优先级的划分（比如有些操作系统只支持 3 级划分：低，中，高），Java 只是给操作系统一个优先级的 参考值，线程最终 在操作系统的优先级 是多少还是由操作系统决定。

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

通常情况下，高优先级的线程将会比低优先级的线程有 更高的几率 得到执行。

2.1 设置线程优先级

我们使用方法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

2.2 优先级只是参考

设置优先级指定线程执行的顺序？

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

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

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

public class Demo {
    public static class T1 extends Thread {
        @Override
        public void run() {
            super.run();
            System.out.println(String.format("当前执行的线程是：%s，优先级：%d",
                    Thread.currentThread().getName(),
                    Thread.currentThread().getPriority()));
        }
    }

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

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

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

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

2.3 守护线程

守护线程

所谓守护线程，是指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程就是一个很称职的守护者，并且这种线程并不属于程序中不可或缺的部分。

用户线程和守护线程两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果用户线程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。 因为没有了被守护者，守护线程也就没有工作可做了，也就没有继续运行程序的必要了。

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

2.4 线程和线程组的优先级

个线程必然存在于一个线程组中，那么当线程和线程组的优先级不一致的时候将会怎样呢？

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

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

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

三、线程组的常用方法

3.1 获取当前的线程组名字

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

3.2 复制线程组

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

3.3 线程组统一异常处理

package com.func.axc.threadgroup;
 
public class ThreadGroupDemo {
	public static void main(String[] args) {
		ThreadGroup threadGroup1 = new ThreadGroup("group1") {
            // 继承ThreadGroup并重新定义以下方法
            // 在线程成员抛出unchecked exception
            // 会执行此方法
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println(t.getName() + ": " + e.getMessage());
            }
        };
        
        // 这个线程是threadGroup1的一员
		Thread thread1 = new Thread(threadGroup1, new Runnable() {
            public void run() {
                // 抛出unchecked异常
                throw new RuntimeException("测试异常");
            }
        });
        
		thread1.start();
	}
}

四、线程组数据结构

4.1 ThreadGroup 源码中的成员变量

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

4.2 构造函数

// 私有构造函数
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);
}

4.3 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.）

五、总结

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