相关阅读：
全面详解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() NEW
System.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() NEW
System.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!");
}
});
// 在线程启动之前获取线程状态：NEW
System.out.println(t.getState());
t.start();
Thread.sleep(5000);
// 此时调用t.getState()获取线程状态，线程仍正在执行，，因此是RUNNABLE
System.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);
}
}
});
// 在线程启动之前获取线程状态：NEW
System.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();
// 创建线程t1
Thread t1 = new Thread(() -> {
synchronized (object) {
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "t1");
// 启动t1
t1.start();
// 创建线程t2
Thread t2 = new Thread(() -> {
synchronized (object) {
System.out.println("hehe");
}
}, "t2");
//启动t2
t2.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();
// 创建线程t1
Thread t1 = new Thread(() -> {
synchronized (object) {
try {
object.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t1");
// 启动t1
t1.start();
// 创建线程t2
Thread t2 = new Thread(() -> {
synchronized (object) {
System.out.println("hehe");
}
}, "t2");
//启动t2
t2.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() {
@Override
public void run() {
while (true) {
System.out.println("张三");
// 先注释掉, 再放开
// Thread.yield();
}
}
}, "t1");
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println("李四");
}
}
}, "t2");
t2.start();
}
}
