【多线程】线程状态

🥰🥰🥰来都来了，不妨点个关注叭！

👉博客主页：欢迎各位大佬!👈

1. 枚举线程所有状态

操作系统里的线程自身是有一个状态，在Java中，Thread是对系统线程的封装，把这里的状态又进一步细化~下面一起来看看线程的状态！
线程的状态是一个枚举类型Thread.State，通过下面代码枚举线程的所有状态

public class ThreadState {public static void main(String[] args) {for (Thread.State state : Thread.State.values()) {System.out.println(state);}}
}

打印结果如下：

具体解释各线程状态含义：
【NEW】 安排工作但还未开始行动，即系统中的线程还没有建出来，只是有个Thread对象
【RUNNABLE】 可工作，可以分为正在工作中和即将开始工作，即就绪状态，分为两种：一是正在CPU上运行；二是准备好随时可以去CPU上运行
【BLOCKED】 排队等着其它的事，具体表示等待锁出现的状态
【WAITING】 排队等着其它的事，具体表示使用wait()方法出现的状态
【TIMED_WAITING】 排队等着其它的事，具体表示指定时间等待，sleep()方法
【TERMINATED】工作完成，表示系统中的线程已经执行完毕，Thread对象仍在
通过示意图，以去银行办理业务为例，以便我们能够更好地了解~如下所示：

这个例子是，把张三找来给他安排任务，但目前没让他行动起来，则是NEW状态

王五和李四等人去银行窗口排队，等待服务，就进入到RUNNABLE状态，该状态并不表示已经被银行工作人员接待，排在队伍中也是属于这个状态，即可被服务状态，是否开始服务则是看调度器的调度~

当王五和李四等人突然有其它的事情需要忙，比如需要填写基本信息等，进入到TIMED_WAITING、BLOCKED、WAITING状态

如果他们忙完了则为TERMINATED状态

通过上图，我们可以看到：

1）TIMED_WAITING、BLOCKED、WAITING状态都表示排队等待
2）前面我们学习过isAlive()方法，判断线程是否存活，NEW和TERMINATED的状态为不存活，其余状态均为活着

下面通过代码具体来看看吧~
1）NEW 表示系统中的线程还没有建出来，只是有个Thread对象

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

运行结果如下图：

2）TERMINATED 表示系统中的线程已经执行完毕，Thread对象仍在

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

运行结果如下图：

3）RUNNABLE 表示可工作状态，可以分为正在工作中和即将开始工作，即就绪状态，分为两种：一是正在CPU上运行；二是准备好随时可以去CPU上运行，即一个“随叫随到”的状态

public class ThreadDemo {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(() -> {while(true) {//System.out.println("hi！");}});// 在线程启动前 获取线程状态getState()----> NEWSystem.out.println(t.getState());t.start();Thread.sleep(3000);// 此时调用t.getState()获取线程状态 线程仍正在执行 看上述代码 死循环 ----> RUNNABLESystem.out.println(t.getState());}
}

运行结果如下图：

4）TIMED_WAITING 表示排队等着其它的事，具体表示指定时间等待，如正在休眠的sleep()方法，即线程正在“指定时间等待”
下述代码中， t 线程内是sleep()休眠，在最后一行代码查询 t 线程状态时，因为t线程正在休眠状态，所以状态为TIMED_WAITING

public class ThreadDemo {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);}}});// 在线程启动前 获取线程状态getState()----> NEWSystem.out.println(t.getState());t.start();Thread.sleep(5000);System.out.println(t.getState());}
}

运行结果如下图：

【为什么要理解线程状态？】
理解线程状态就是为了让我们能够更好的进行多线程代码调试!!!

2. 线程转移

2.1 示意图

【简化】一条主线，三条支线

详细补充如下图：

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

2.2 观察 NEW 、 RUNNABLE 、 TERMINATED 状态的转换

使用 isAlive() 方法判定线程的存活状态
通过以下代码可以观察到线程在NEW、RUNNABLE和TERMINATED三个状态之间的转换:

public class ThreadStateTransfer {public static void main(String[] args) throws InterruptedException {Thread t = new Thread(() -> {for (int i = 0; i < 100; 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 线程中的线程体中设置循环，执行 100次(设置为100次，为方便起见)，循环执行完毕后即线程终止，具体过程如下：
1）线程启动前，此时线程的状态为NEW，即线程还没有建出来，只是有个Thread对象
2）在线程的存活期间内，此时调用线程为RUNNABLE 的状态，即就绪状态

【回顾isAlive() 方法】
isAlive()该方法用于判定线程的存活状态，存活指的是线程已启动且尚未终止，当线程正在运行或着准备开始运行的时候，该方法就认为线程是“存活”的，并以true或false的形式返回

3）在线程终止后，此时线程的状态为TERMINATED，即线程已经执行完毕

2.3 观察 WAITING 、 BLOCKED 、 TIMED_WAITING 状态的转换

通过以下代码可以观察到线程在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("xixi");}}, "t2");//启动t2t2.start();}
}

使用jconsole工具可以观察，如下图：

【解释说明】
创建 t1 线程，给 t1 线程加锁，t1 线程内不断进行休眠sleep()操作
创建 t2 线程，给 t2 线程加锁，t2 线程内打印xixi
通过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("xixi");}}, "t2");//启动t2t2.start();}
}

使用 jconsole 可以看到 t1 的状态是 WAITING，如下图：

打印台信息如下：

【解释说明】
t1 线程中调用的 object.wait() 方法

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

所以在上述代码中，当 t1 调用 object.wait() 方法时，它会释放 object 对象的锁，即在 t1 等待时，其他线程比如如这里的 t2 线程，可以获得该对象的锁并执行同步块中的代码，打印出xixi，但只有当 t1 线程被唤醒并重新获得对象的锁时，它才会继续执行同步块中的代码。t1一直不被唤醒，就一直处于无限等待的状态，此时查看 t1 的线程状态，为WAITING
【结论】
1）BLOCKED 与 WAITING 、TIMED_WAITING的区别
BLOCKED 表示等待获取锁，WAITING 和 TIMED_WAITING 表示等待其他线程发来通知
2） TIMED_WAITING 与 WAITING 的区别
TIMED_WAITING 线程在等待唤醒，但是设置了时限；而WAITING 线程在无限地等待唤醒

2.4 yield()让出CPU

yield() 不改变线程的状态， 但会让线程重新去排队，下面具体介绍yield()方法：
1）yield() 方法介绍
yield() 方法是Java中的一个静态方法，它属于 Thread类，用于使当前线程让出CPU资源，让其他具有相同或更高优先级的线程运行
2）yield() 方法作用
调用 yield()方法并不会释放锁或者阻塞当前线程，它只是暂停当前线程的执行，并允许其他线程先获得执行，当当前线程被重新调度时，它将继续执行，但并不能保证它会立即被调度!!!
3）yield() 方法的调用
调用 yield() 方法并不能保证其他线程会获得执行，因为调度器可以选择忽略 yield() 方法的调用。过度使用 yield() 方法可能会导致性能问题，频繁的调用 yield() 方法可能会导致线程频繁地切换，从而降低系统的性能
4）yield() 方法的使用场景
通常情况下，使用 yield()方法是为了避免长时间的占用CPU资源。

public class Test1 {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();}
}

打印结果，可自行运行代码观察，通过观察得知：
1）不使用 yield() 时， 打印“柚子”与“球球”数量大概是各占一半
2）使用 yield 时， 打印“柚子”的数量远远少于“球球”
【原因】
每次执行到 t1线程中的 Thread.yield() 方法时，都会使 t1 线程暂时让出CPU资源，重新去排队，让 t2 线程先获得执行，即 t2 线程被执行到的次数就大大增加了
💛💛💛本期内容回顾💛💛💛

✨✨✨本期内容到此结束啦~下期内容将介绍线程安全，多线程带来的风险！（期待ing）