一、观察线程中的所有状态
用 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 对象还在。
1.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(); } }
可以观察到，在不使用 yield 时，打印的“ 张三”和“李四”数量大概各占一半；但使用 yield 后 , “ 张三”的数量远远少于“李四”。这是因为每次执行到t1线程中的 Thread.yield() 方法时，都会使t1线程暂时让出CPU资源，让t2线程获得执行。t2线程可以被执行到的次数就大大增加了。
————————————————
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
原文链接：https://blog.csdn.net/wyd_333/article/details/129938307
