联壁峰--多线程系列之线程组和线程优先级(三)

小宋带大家继续深入多线程的学习，本章讲解一下关于线程组以及线程优先级的相关知识。

线程组

我们先普及一下线程组的概念。

java中用ThreadGroup来表示线程组，我们可以使用线程组对线程进行批量操作。
ThreadGroup和Thread的关系就如同他们的字面意思，每个Thread必然存在于一个ThreadGroup中，Thread不能独立于ThreadGroup存在。执行main()方法线程的名字是main，如果在new Thread时没有显示指定，那么默认将父线程(当前执行new Thread的线程)线程组设置为自己的线程组。

eg.

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，线程的执行顺序由调度程序来决定，线程的优先级会在线程被调用之前设定。

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

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的级别来设定了线程的优先级，那么我们是不是可以在业务实现的时候，采用这种方式来指定一些线程执行的先后顺序?
答案是:不行！
在上面的时候就有强调过一个点，Java中的优先级不是特别的可靠，因为Java程序中对线程所设置的优先级只是给操作系统一个建议，操作系统不一定会采纳。真正的调用顺序，是由操作系统的线程调度算法决定的。
eg.

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),守护线程的默认优先级比较低。
如果某个线程是守护线程的话，当所有的非守护线程都结束了，这个守护线程也会自动结束。
应用场景: 当所有非守护线程结束时，结束其余的子线程(守护线程)会自动关闭，就免去了还要继续关闭子线程的麻烦。
一个线程默认是非守护线程，可以通过Thread类的setDaemon(boolean on)来设置。

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

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.getName()+"："+threadGroup.getMaxPriority());
        System.out.println("我是线程的优先级"+thread.getName()+"："+thread.getPriority());
    }

输出:
我是线程组的优先级t1：6
我是线程的优先级thread：6

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

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

接着我们讲一下线程组中有哪些常用的方法和它的数据结构

线程组的常用方法

获取当前线程组的名字

Thread.currentThread.getThreadGroup.getName();

复制线程组

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

线程组统一异常处理

  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();
    }
}

线程组的数据结构

线程组还可以包含其他的线程组，不仅仅是线程。
看一下ThreadGroup源码的成员变量

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[]; // 线程组数组

再看一下构造函数:

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

检查parent ThreadGroup

判断当前运行的线程是否具有修改线程组的权限
这里涉及到SecurityManager这个类，它是Java的安全管理器，它允许应用程序在执行一个可能不安全或敏感的操作前确定该操作是什么，以及是否是在允许执行该操作的安全上下文中执行它。应用程序可以允许或不允许该操作。
比如引入了第三方类库，但是并不能保证它的安全性。
其实Thread类也有一个checkAccess()方法，不过是用来当前运行的线程是否有权限修改被调用的这个线程实例。（Determines if the currently running thread has permission to modify this thread.）