相关阅读：

全面详解Java多线程基础-1：Thread类及其基本用法

操作系统里的进程，自身是有一个状态的。而Java的Thread类是对系统线程的封装，它把这里的“状态”又进一步精细化了。

理解线程状态，意义是能够让我们更好地进行多线程代码的调试。例如，当发现两个线程都处在 BLOCKED 状态，就可考虑是否发生的死锁。

目录

一、观察线程中的所有状态

1、NEW

2、TERMINATED

3、RUNNABLE

4、TIMED_WAITING

二、线程状态的转移

1、示意图概述

2、关注 NEW 、 RUNNABLE 、 TERMINATED 状态的转换

3、关注 WAITING 、 BLOCKED 、 TIMED_WAITING 状态的转换

4、yield()让出CPU

一、观察线程中的所有状态

用 t.getState() 方法查看调用时线程的状态。

线程的状态包括：

• NEW：系统中的线程还没创建出来，只是有了一个 Thread 对象（已经安排好了工作，但是还未开始行动）。

• TERMINATED：系统中的线程已经执行完了，但 Thread 对象还在（工作已经完成了）。
• RUNNABLE：就绪状态。有两种可能的情况：①线程正在CPU上运行；②线程已经准备好随时可以去CPU上运行（表示“可工作的”状态；又可以分成正在工作中和即将开始工作）。
• TIMED_WAITING：线程正在“指定时间等待”，表示线程在有限时地等待唤醒（等待其它线程发来通知）。一个典型的状况就是线程正在休眠sleep()。
• BLOCKED：表示等待获取锁的状态。
• WAITING：使用 wait() 方法出现，表示线程在无限时等待唤醒（等待其它线程发来通知）。

TIMED_WAITING、BLOCKED、WAITING都表示排队等着其他某件事情。

 

1、NEW

NEW 表示系统中的线程还没创建出来，只是有了一个 Thread 对象。

public class ThreadDemo {public static void main(String[] args) {Thread t = new Thread(() -> {System.out.println("good!");});// 在线程启动之前，获取线程状态 getState()  NEWSystem.out.println(t.getState());t.start();}
}

2、TERMINATED

TERMINATED 表示系统中的线程已经执行完了，但 Thread 对象还在。

public class ThreadDemo {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(() -> {System.out.println("good!");});// 在线程启动之前，获取线程状态 getState()  NEWSystem.out.println(t.getState());t.start();// 线程已经执行完了，但Thread对象还在  TERMINATED// 为了保证调用t.getState()的时候，线程已经执行完了，先调用sleep让main线程休眠等待Thread.sleep(5000);System.out.println(t.getState());}
}

3、RUNNABLE

表示线程处于就绪状态。

它有两种可能的情况：①线程正在CPU上运行；②准备好随时可以去CPU上运行。

概括来说，就是一个“随叫随到”的状态。

public class Test {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(() -> {while(true) {//System.out.println("hello!");}});// 在线程启动之前获取线程状态：NEWSystem.out.println(t.getState());t.start();Thread.sleep(5000);// 此时调用t.getState()获取线程状态，线程仍正在执行，，因此是RUNNABLESystem.out.println(t.getState());}
}

4、TIMED_WAITING

表示线程正在“指定时间等待”。一个典型的状况就是线程正在休眠sleep()。

如下面代码中，在 t 线程内，做的事情就是 sleep() 休眠。这样，最后一行代码查询线程状态时，由于 t 线程正在休眠，即正在“指定时间等待”，因此就会显示状态为TIMED_WAITING。

public class Test {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(() -> {while(true) {try {Thread.sleep(3000);} catch (InterruptedException e) {throw new RuntimeException(e);}}});// 在线程启动之前获取线程状态：NEWSystem.out.println(t.getState());t.start();Thread.sleep(5000);System.out.println(t.getState());}
}

二、线程状态的转移

1、示意图概述

*一条主线，三条支线。

详细补充：

（图片来自：https://blog.csdn.net/pange1991）

2、关注 NEW 、 RUNNABLE 、 TERMINATED 状态的转换

通过以下代码可以观察到线程在NEW、RUNNABLE和TERMINATED三个状态之间的转换。

public class Test {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(() -> {for (int i = 0; i < 1000_0000; i++) {//循环体是空的}}, "线程t");// ①在线程启动之前System.out.println(t.getName() + ": " + t.getState());t.start();while (t.isAlive()) {// ②在线程存活期间System.out.println(t.getName() + ": " + t.getState());}// ③在线程终止后System.out.println(t.getName() + ": " + t.getState());;}
}

首先，我们创建一个线程t。t 的线程体中设置一个循环，该循环将执行 10000000 次，循环执行完毕后线程便终止了。

然后，我们分别在三个位置查看线程t的状态：

①在线程启动之前。此时线程的状态是NEW。

②在线程的存活期间内。isAlive 方法用于判定线程的存活状态，存活指的是线程已经启动且尚未终止，当线程正在运行或着准备开始运行的时候，该方法就认为线程是“存活”的，并以true或false的形式返回。此时调用线程可以得到 RUNNABLE 的状态。

③在线程终止后。这时，线程的状态是TERMINATED。

3、关注 WAITING 、 BLOCKED 、 TIMED_WAITING 状态的转换

通过以下代码和jconsole工具可以观察到线程在WAITING、BLOCKED和TIMED_WAITING 三个状态之间的转换。

public class Test {public static void main(String[] args) throws InterruptedException {final Object object = new Object();// 创建线程t1Thread t1 = new Thread(() -> {synchronized (object) {while (true) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}}, "t1");// 启动t1t1.start();// 创建线程t2Thread t2 = new Thread(() -> {synchronized (object) {System.out.println("hehe");}}, "t2");//启动t2t2.start();}
}

创建 t1 线程，并给该线程加锁；线程体内t1线程不断进行休眠sleep()操作。

创建 t2 线程，也给 t2 线程加锁；在t2线程中打印hehe。

启动进程并打开jconsole，可以观察到，t1 的状态为 TIME_WAITING，t2 的状态为 BLOCKED。

这是因为启动t1时，t1获得了锁，并进入了sleep循环。此时的t1一直在进行“指定时间等待”的操作，因此状态为 TIME_WAITING。启动t2，此时t1还未释放锁，t2只能等待获取锁。t1一直不释放锁，t2就只能一直等待。因此，t2的状态是BLOCKED。

此时控制台的状况为一片空白，即什么也没有打印。

如果此时，我们把t1中的sleep改成wait，t1的状态就变为了WAITING。

public class Test {public static void main(String[] args) throws InterruptedException {final Object object = new Object();// 创建线程t1Thread t1 = new Thread(() -> {synchronized (object) {try {object.wait();} catch (InterruptedException e) {e.printStackTrace();}}}, "t1");// 启动t1t1.start();// 创建线程t2Thread t2 = new Thread(() -> {synchronized (object) {System.out.println("hehe");}}, "t2");//启动t2t2.start();}
}

这里必须特别注意t1线程中调用的 object.wait() 方法。

在Java中，线程必须持有对象的锁才能调用 wait() 方法。当线程调用 wait() 方法时，它会释放当前持有的锁，并将自己挂起，直到被其他线程唤醒。一旦线程调用了 wait() 方法并释放了锁，其他线程就可以获取该对象的锁并继续执行同步块中的代码。当该线程被唤醒（notify）时，它会重新尝试获取对象的锁并恢复执行。但是，在其它线程未释放锁之前该线程仍然会被阻塞。一旦它获得了对象的锁，它才可以继续执行同步块中的代码。

因此，在上面的代码中，当 t1 调用 object.wait() 方法时，它会释放 object 对象的锁。这意味着，在 t1 等待时，其他线程（如 t2）可以获得该对象的锁并执行同步块中的代码，打印出hehe。但是，只有当 t1 线程被唤醒并重新获得对象的锁时，它才会继续执行同步块中的代码。t1一直不被唤醒，就一直处于无限等待的状态。此时查看t1的线程状态，可见为WAITING。

这里我们可以得出结论：

• BLOCKED 表示等待获取锁，WAITING 和 TIMED_WAITING 表示等待其他线程发来通知。
• TIMED_WAITING 线程在等待唤醒，但是设置了时限的；WAITING 线程在无限地等待唤醒。

4、yield()让出CPU

yield 不会改变线程的状态，但会让线程重新去排队。

yield() 方法是Java中的一个静态方法，它属于 Thread 类，用于使当前线程让出CPU资源，让其他具有相同或更高优先级的线程运行。调用 yield() 方法并不会释放锁或者阻塞当前线程，它只是暂停当前线程的执行，并允许其他线程获得执行。当当前线程被重新调度时，它将继续执行，但并不能保证它会立即被调度。

但是，调用 yield() 方法并不能保证其他线程会获得执行，因为调度器可以选择忽略 yield() 方法的调用。过度使用 yield() 方法可能会导致性能问题，因为频繁的调用 yield() 方法可能会导致线程频繁地切换，从而降低系统的性能。

通常情况下，使用 yield() 方法是为了避免长时间的占用CPU资源。

public class Test {public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(new Runnable() {@Overridepublic void run() {while (true) {System.out.println("张三");// 先注释掉, 再放开// Thread.yield();}}}, "t1");t1.start();Thread t2 = new Thread(new Runnable() {@Overridepublic void run() {while (true) {System.out.println("李四");}}}, "t2");t2.start();}
}