校园课程助手【3】

1、6种状态及切换

我们先来看看操作系统中的线程状态转换。在操作系统open in new window中，线程被视为轻量级的进程，所以线程状态其实和进程状态是一致的。

操作系统的线程主要有以下三个状态：

然后我们来看 Java 线程的 6 个状态：

// Thread.State 源码
public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

 1.NEW

private void testStateNew() {
    Thread thread = new Thread(() -> {});
    System.out.println(thread.getState()); // 输出 NEW
}

在这里例子中，线程在调用start()之前处于NEW的状态

关于 start 的两个引申问题

要分析这两个问题，我们先来看看start()的源码： 

// 使用synchronized关键字保证这个方法是线程安全的
public synchronized void start() {
    // threadStatus != 0 表示这个线程已经被启动过或已经结束了
    // 如果试图再次启动这个线程，就会抛出IllegalThreadStateException异常
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    // 将这个线程添加到当前线程的线程组中
    group.add(this);

    // 声明一个变量，用于记录线程是否启动成功
    boolean started = false;
    try {
        // 使用native方法启动这个线程
        start0();
        // 如果没有抛出异常，那么started被设为true，表示线程启动成功
        started = true;
    } finally {
        // 在finally语句块中，无论try语句块中的代码是否抛出异常，都会执行
        try {
            // 如果线程没有启动成功，就从线程组中移除这个线程
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            // 如果在移除线程的过程中发生了异常，我们选择忽略这个异常
        }
    }
}

 可以看到，在start()内部，有一个 threadStatus 变量。如果它不等于 0，调用start()会直接抛出异常。

接着往下看，有一个 nativeopen in new window 的 start0() 方法。这个方法并没有对threadStatus进行处理。到这里我们仿佛拿这个 threadStatus 没辙了，通过 debug 再看一下:

@Test
public void testStartMethod() {
    Thread thread = new Thread(() -> {});
    thread.start(); // 第一次调用
    thread.start(); // 第二次调用
}

在 start 方法内部的最开始打断点：

 结合上面的源码可以得到的答案是：

2.RUNNABLE

 3.BLOCKED

我们用 BLOCKED 状态举个生活中的例子：

假如今天你下班后准备去食堂吃饭。你来到食堂仅有的一个窗口，发现前面已经有个人在窗口前了，此时你必须得等前面的人从窗口离开才行。

假设你是线程 t2，你前面的那个人是线程 t1。此时 t1 占有了锁（食堂唯一的窗口），t2 正在等待锁的释放，所以此时 t2 就处于 BLOCKED 状态。

4.WAITING

 我们延续上面的例子继续解释一下 WAITING 状态：

你等了好几分钟，终于轮到你了，突然你们有一个“不懂事”的经理来了。你看到他你就有一种不祥的预感，果然，他是来找你的。

他把你拉到一旁叫你待会儿再吃饭，说他下午要去作报告，赶紧来找你了解一下项目的情况。你心里虽然有一万个不愿意但是你还是从食堂窗口走开了。

此时，假设你还是线程 t2，你的经理是线程 t1。虽然你此时都占有锁（窗口）了，“不速之客”来了你还是得释放掉锁。此时你 t2 的状态就是 WAITING。然后经理 t1 获得锁，进入 RUNNABLE 状态。

要是经理 t1 不主动唤醒你 t2（notify、notifyAll..），可以说你 t2 只能一直等待了。

5.TIMED_WAITING

 我们继续延续上面的例子来解释一下 TIMED_WAITING 状态：

到了第二天中午，又到了饭点，你还是到了窗口前。

突然间想起你的同事叫你等他一起，他说让你等他十分钟他改个 bug。

好吧，那就等等吧，你就离开了窗口。很快十分钟过去了，你见他还没来，你想都等了这么久了还不来，那你还是先去吃饭好了。

这时你还是线程 t1，你改 bug 的同事是线程 t2。t2 让 t1 等待了指定时间，此时 t1 等待期间就属于 TIMED_WATING 状态。

t1 等待 10 分钟后，就自动唤醒，拥有了去争夺锁的资格。

6.TERMINTED

3、线程状态的转换

在java中，线程状态的转换是由java虚拟机(jvm)自动管理的，这些状态转换通常是由线程的执行行为触发的

3.1 BLOCKED 与 RUNNABLE 状态的转换

我们在上面说过：处于 BLOCKED 状态的线程在等待锁的释放。假如这里有两个线程 a 和 b，a 线程提前获得了锁并暂未释放锁，此时 b 就处于 BLOCKED 状态。我们来看一个例子：

@Test
public void blockedTest() {
    Thread a = new Thread(new Runnable() {
        @Override
        public void run() {
            testMethod();
        }
    }, "a");

    Thread b = new Thread(new Runnable() {
        @Override
        public void run() {
            testMethod();
        }
    }, "b");

    a.start();
    b.start();

    System.out.println(a.getName() + ":" + a.getState()); // 输出？
    System.out.println(b.getName() + ":" + b.getState()); // 输出？
}

// 同步方法争夺锁
private synchronized void testMethod() {
    try {
        Thread.sleep(2000L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

初看之下，大家可能会觉得线程 a 会先调用同步方法，同步方法内又调用了Thread.sleep()方法，必然会输出 TIMED_WAITING，而线程 b 因为等待线程 a 释放锁所以必然会输出 BLOCKED。

其实不然，有两点需要值得大家注意：

测试方法的 main 线程只保证了 a，b 两个线程调用 start 方法（转化为 RUNNABLE 状态），如果 CPU 执行效率高一点，还没等两个线程真正开始争夺锁，就已经打印此时两个线程的状态（RUNNABLE）了。

当然，如果 CPU 执行效率低一点，其中某个线程也是可能打印出 BLOCKED 状态的（此时两个线程已经开始争夺锁了）。

过程分析：

这时你可能又会问了，要是我想要打印出 BLOCKED 状态我该怎么处理呢？

BLOCKED 状态的产生需要两个线程争夺锁才行。那我们处理下测试方法里的 main 线程就可以了，让它“休息一会儿”，调用一下Thread.sleep()方法。

这里需要注意的是 main 线程休息的时间，要保证在线程争夺锁的时间内，不要等到前一个线程锁都释放了你再去争夺锁，此时还是得不到 BLOCKED 状态的。

我们把上面的测试方法 blockedTest 改动一下：

public void blockedTest() throws InterruptedException {
    ······
    a.start();
    Thread.sleep(1000L); // 需要注意这里main线程休眠了1000毫秒，而testMethod()里休眠了2000毫秒
    b.start();
    System.out.println(a.getName() + ":" + a.getState()); // 输出？
    System.out.println(b.getName() + ":" + b.getState()); // 输出？
}

运行结果如下所示：

在这个例子中两个线程的状态转换如下

3.2 WAITING 状态与 RUNNABLE 状态的转换

Object.wait()

调用wait()方法前线程必须持有对象的锁。

线程调用wait()方法时，会释放当前的锁，直到有其他线程调用notify()/notifyAll()方法唤醒等待锁的线程。

Thread.join()

调用join()方法，会一直等待这个线程执行完毕（转换为 TERMINATED 状态）。

我们再把上面的例子线程启动那里改变一下：

public void blockedTest() {
    ······
    a.start();
    a.join();
    b.start();
    System.out.println(a.getName() + ":" + a.getState()); // 输出 TERMINATED
    System.out.println(b.getName() + ":" + b.getState());
}

要是没有调用 join 方法，main 线程不管 a 线程是否执行完毕都会继续往下走。

a 线程启动之后马上调用了 join 方法，这里 main 线程就会等到 a 线程执行完毕，所以这里 a 线程打印的状态固定是TERMINATED。

至于 b 线程的状态，有可能打印 RUNNABLE（尚未进入同步方法），也有可能打印 TIMED_WAITING（进入了同步方法）。

4、TIMED_WAITING 与 RUNNABLE 状态转换

TIMED_WAITING 与 WAITING 状态类似，只是 TIMED_WAITING 状态等待的时间是指定的。

Thread.sleep(long)

Object.wait(long)

Thread.join(long)

join(long)使当前线程执行指定时间，并且使线程进入 TIMED_WAITING 状态。

我们再来改一改刚才的示例:

public void blockedTest() {
    ······
    a.start();
    a.join(1000L);
    b.start();
    System.out.println(a.getName() + ":" + a.getState()); // 输出 TIEMD_WAITING
    System.out.println(b.getName() + ":" + b.getState());
}

这里调用a.join(1000L)，因为是指定了具体 a 线程执行的时间的，并且执行时间是小于 a 线程 sleep 的时间，所以 a 线程状态输出 TIMED_WAITING。

b 线程状态仍然不固定（RUNNABLE 或 BLOCKED）。

线程中断

在某些情况下，我们在线程启动后发现并不需要它继续执行下去时，需要中断线程。目前在 Java 里还没有安全方法来直接停止线程，但是 Java 提供了线程中断机制来处理需要中断线程的情况。

线程中断机制是一种协作机制。需要注意，通过中断操作并不能直接终止一个线程，而是通知需要被中断的线程自行处理。

简单介绍下 Thread 类里提供的关于线程中断的几个方法：

 代码举例：

public class InterruptExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                // 执行一些长时间运行的任务
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("线程正在运行...");
                    Thread.sleep(1000); // 模拟耗时操作
                }
            } catch (InterruptedException e) {
                // 捕获InterruptedException异常，线程被中断时会抛出此异常
                System.out.println("线程被中断");
            }
        });

        thread.start();

        // 稍后中断线程
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 调用interrupt()方法设置中断状态
        thread.interrupt();
    }
}

运行结果：

线程正在运行...
线程正在运行...
线程正在运行...
线程正在运行...
线程正在运行...
线程被中断

5、线程的优先组和优先级

1.线程组

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

创建线程组：

ThreadGroup group =new ThreadGroup("MyThreadGroup");

也可以通过指定父线程来创建子线程组：

ThreadGroup parent=Thread.currentThread().getThreadGrouo();
ThreadGroup child =new ThreadGroup(parent,"childThreadGroup");

使用线程组：

当你创建一个新的线程的时候，可以通过指定线程组来将线程加入到特定的线程组中：

Thread thread = new Thread(group, new Runnable() {
    @Override
    public void run() {
        // 线程执行代码
    }
}, "MyThread");

练习： 

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
testThread当前线程组名字：main
testThread线程名字：Thread-0
执行main方法线程名字：main

为什么会这样子运行？

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

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

获取当前线程的线程组名字

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

复制线程组：

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

线程组统一异常处理

// 创建一个线程组，并重新定义异常
ThreadGroup group = new ThreadGroup("testGroup") {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println(t.getName() + ": " + e.getMessage());
    }
};

// 测试异常
Thread thread = new Thread(group, () -> {
    // 抛出 unchecked 异常
    throw new RuntimeException("测试异常");
});

// 启动线程
thread.start();

线程组的数据结构

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

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

    int nUnstartedThreads = 0; // 还未启动的线程
    int nthreads; // ThreadGroup中线程数目
    Thread threads[]; // ThreadGroup中的线程

    int ngroups; // 线程组数目
    ThreadGroup groups[]; // 线程组数组
}

3.线程的优先级

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

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

通常情况下，高优先级的线程将会比低优先级的线程有更高的概率得到执行。Thread类的setPriority()方法可以用来设定线程的优先级，通过getPriority()方法来获取线程当前的优先级。

Thread a = new Thread();
System.out.println("我是默认线程优先级："+a.getPriority());
Thread b = new Thread();
b.setPriority(10);
System.out.println("我是设置过的线程优先级："+b.getPriority());

输出结果：

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

既然有 10 个级别来设定线程的优先级，那是不是可以在业务实现的时候，采用这种方法来指定线程执行的先后顺序呢？

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

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

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

static class MyThread extends Thread {
    @Override
    public void run() {
        // 输出当前线程的名字和优先级
        System.out.println("MyThread当前线程：" + Thread.currentThread().getName()
                + ",优先级：" + Thread.currentThread().getPriority());
    }
}

public static void main(String[] args) {
    // 创建 10 个线程，从 1-10 运行，优先级从 1-10
    for (int i = 1; i <= 10; i++) {
        Thread thread = new MyThread();
        thread.setName("线程" + i);
        thread.setPriority(i);
        thread.start();
    }
}

运行结果：

MyThread当前线程：线程2,优先级：2
MyThread当前线程：线程4,优先级：4
MyThread当前线程：线程3,优先级：3
MyThread当前线程：线程5,优先级：5
MyThread当前线程：线程1,优先级：1
MyThread当前线程：线程6,优先级：6
MyThread当前线程：线程7,优先级：7
MyThread当前线程：线程8,优先级：8
MyThread当前线程：线程9,优先级：9
MyThread当前线程：线程10,优先级：10

Java 提供了一个线程调度器来监视和控制处于RUNNABLE 状态的线程。

还有一种特殊的线程，叫做守护线程（Daemon），守护线程默认的优先级比较低。

线程组和线程优先级之间的关系 

// 创建一个线程组
ThreadGroup group = new ThreadGroup("testGroup");
// 将线程组的优先级指定为 7
group.setMaxPriority(7);
// 创建一个线程，将该线程加入到 group 中
Thread thread = new Thread(group, "test-thread");
// 企图将线程的优先级设定为 10
thread.setPriority(10);
// 输出线程组的优先级和线程的优先级
System.out.println("线程组的优先级是：" + group.getMaxPriority());
System.out.println("线程的优先级是：" + thread.getPriority());

输出：

线程组的优先级是：7
线程的优先级是：7

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