[Java]线程生命周期与线程通信

【版权声明】未经博主同意，谢绝转载！（请尊重原创，博主生存追究权）
https://www.cnblogs.com/cnb-yuchen/p/18162522
出自【进步*于辰的博客】

线程生命周期与进程有诸多相似，所以我们很容易将两者关联理解并肴杂，一些细节之处确有许多差别，因为线程调理与进程调理虽都由CPU完成，但两者并不雷同。
特意泯灭一些时间，系统地对线程生命周期与线程通信进行梳理、整理。

目录

• 1、线程生命周期
  
  
  
  • 1.1 JDK1.8版本
    
  • 1.2 早期版本（JDK1.2之前）
    
  • 1.3 落到实处
    
  
  
• 2、线程通信
  
  
  
  • 2.1 使用 volatile 关键字
    
  • 2.2 使用Object类的wait()和notify()
    
  • 2.3 使用JUC工具类 CountDownLatch
    
  • 2.4 使用 ReentrantLock 结合 Condition
    
  • 2.5 使用 LockSupport
    
  
  
• 最后
  

1、线程生命周期

1.1 JDK1.8版本

启发博文：《线程的生命周期及五种基本状态》（转发）。

引用其中一张线程生命周期图：

在启发博文中，博主对线程五大状态和生命周期进行了很详细的说明，大家可以先行查阅。
这张图对线程生命周期总结得比力全面，我逐一梳理、核对后觉得稍有不妥之处，略作修改后作如下图：

在此我先简述一下我对线程五个状态的理解：

• new（新建）：在线程创建后、启动（start()）之前所处的状态。
  
• Runnable（停当）：线程新建后并不是直接开始运行，而是被加入到等待队列，等待线程调理（等待CPU），此时就处于停当状态。因此，这两种情况将进入停当状态：(1)调用start()；(2)因某种缘故原由（如：线程通信、等待IO）进入阻塞状态后重新等待运行。
  
• Running（运行）：线程正在运行时的状态。
  
• Blocked（阻塞）：线程因某种缘故原由（如：线程通信、等待IO）而停止运行后进入的状态。
  
• Dead（死亡）：线程正常竣事或异常停止后所处的状态。
  

相信大家在阅读完以上简述后，对线程的五大状态已经有了一个开端的认识，那状态间是如何转换的？又怎么理解呢？对于这两个问题，由于涉及到各个方法的业务和底层逻辑，本篇文章未便逐一详述。如果大家想要进一步了解，可移步 → 《Thread类源码剖析》。
其中，Blocked状态可能不太好理解，那位博主将其划分为三种情况：等待阻塞、同步阻塞和其他阻塞。我赞同，大家可移步启发博文查阅详述，在此不赘述，仅稍作说明：

三种阻塞情况的变动主要因“线程通信”引起，变化仅是阻塞情况的变化，状态不变，还是Blocked。

点出两个问题：
1：为什么调用notify()/notifyAll()，线程由等待Blocked变为锁定Blocked？
文章排版考虑，在下文【使用Object类的wait()和notify()】中说明。
2：interrupt()可停止线程，那么可停止正在阻塞的线程吗？
本质上说，可以，但会抛出异常（即不可以，故我未将其写入上图），在上文我给出的《Thread类源码剖析》文章中有具体说明。
1.2 早期版本（JDK1.2之前）

相信能坚持阅读到这的博友，大部门是站在Java门槛上或刚入门不久的Java小白，你们如今了解和学习线程生命周期，得到的是已更新、迭代后的知识。个人认为，大家不需要掌握已过期的知识，但不能不了解，我先抛出两个问题：

• “挂起”状态是什么？怎么不在线程五大状态之列？
  
• 相信大家在一些资料中，可能见到过suspend()、resume()、stop()或destroy()这4个方法，怎么上图中没有？为什么不消了？
  

当然是有的，只是过期了，所以没放上去，完整的图是这样：

OK，如今回答那两个问题。

“挂起”状态是一种类似Runnable（停当）状态的状态，差别之处是进入停当状态的线程，会开释所持有的“同步锁”，而“挂起”状态不会，“挂起”状态相称于“停息”，故容易导致“死锁”。

为什么那4个方法会被放弃？
我寻得一答案，阐述得很详细，我便不班门弄斧了，看这里 → 《《Java面向对象编程》导读-Thread类的被废弃的suspend()、resume()和stop()方法》（转发）。
我补充一张图：

1.3 落到实处

所谓“落到实处”，就是要想掌握线程生命周期，光如上文夸夸其谈当然还不敷，我们要把线程五大状态和状态间转换对应到Thread源码中才行。
如下图：

我自己感觉有点乱，源码所示云云。
当然，这不是完整图，图中状态间转换仅做了部门举例。在此，我不作说明，相名誉心看到这里的博友可以大抵理解。当然，也未便做出说明，因为我目前对一些方法的了解停留在“会用”的程度（见下文），并未对相应源码进行剖析。
补充一点：
大家对比这张“状态图”和上文线程生命周期图，大家会发现有点对不上。
实在，WAITING就是Runnable（停当），在线程生命周期中，一般不说“停当”，“停当”是进程生命周期中的术语，上文这般使用是为了方便大家理解；而RUNNABLE就是Running。
2、线程通信

启发博文：《线程间通信的几种实现方式》（转发）。

我暂未整理“线程通信”相干理论，故下文将以示例的情势进行阐述。
注：以下5个示例都乐成实现线程通信，输出结果是：

1. 唤醒t1
2. t1已唤醒

复制代码

2.1 使用 volatile 关键字

示例：

1. private static volatile boolean isWait = true;
3. public static void main(String[] args) {
4.     Thread t1 = new Thread(() -> {
5.         while (true)
6.             if (!isWait) {
7.                 System.out.println("t1已唤醒");
8.                 break;
9.             }
10.     });
11.     Thread t2 = new Thread(() -> {
12.         System.out.println("唤醒t1");
13.         isWait = false;
14.     });
15.     t1.start();
16.     t2.start();
17. }

复制代码

如果大家不了解volatile关键字，看这里。

这里线程通信使用的是volatile关键字“包管可见性”的原理。
2.2 使用Object类的wait()和notify()

示例：

1. Object lock = new Object();
2. Thread t1 = new Thread(() -> {
3.     synchronized (lock) {
4.         try {
5.             lock.wait();
6.         } catch (InterruptedException e) {
7.             e.printStackTrace();
8.         }
9.         System.out.println("t1已唤醒");
10.     }
11. });
12. Thread t2 = new Thread(() -> {
13.     synchronized (lock) {
14.         System.out.println("唤醒t1");
15. //      lock.notify();// 唤醒等待队列中的一个线程，不一定是 t1
16.         lock.notifyAll();
17.     }
18. });
19. t1.start();
20. t2.start();

复制代码

大家还记得我在【1.1】中点出的这个问题吗？

为什么调用notify()/notifyAll()，线程由等待Blocked变为锁定Blocked？

答案就在以上代码的执行过程中，我给大家捋一捋。

1. 1、t1、t2都执行，t1在t2之前启动，先获得同步锁，t2阻塞。
2. 2、t1调用wait()进入等待状态，释放同步锁，同步锁由t2获得，t2开始运行。
3. 3、t2调用notify()唤醒t1，但此时同步锁仍由t2持有，t1继续等待。
4. 4、t2运行完，释放同步锁，由t1获得，t1开始运行。

复制代码

OK，就是第3点。
为什么一定要同步锁？
因为wait()与notify()的底层逻辑要求必须是“先等待，再唤醒”，同步锁可以包管流程的正常执行。难道真的不能去掉同步锁？比方这样：

1. Object lock = new Object();
2. Thread t1 = new Thread(() -> {
3.     try {
4.         lock.wait();
5.     } catch (InterruptedException e) {
6.         e.printStackTrace();
7.     }
8.     System.out.println("t1已唤醒");
9. });
10. Thread t2 = new Thread(() -> {
11.     System.out.println("唤醒t1");
12.     lock.notifyAll();
13. });
14. t1.start();
15. t1.join();
16. t2.start();

复制代码

很明显，不可。这样就出现了“死锁”。

t1 等待被唤醒，主线程等待 t1 运行完。

因此，必须使用同步锁，且必须是同一把锁（lock）、
2.3 使用JUC工具类 CountDownLatch

示例：

1. CountDownLatch latch = new CountDownLatch(1);// 这个 1 是同步状态，类似synchronized中的 count
2. Thread t1 = new Thread(() -> {
3.     try {
4.         latch.await();
5.     } catch (InterruptedException e) {
6.         e.printStackTrace();
7.     }
8.     System.out.println("t1已唤醒");
9. });
10. Thread t2 = new Thread(() -> {
11.     System.out.println("唤醒t1");
12.     latch.countDown();
13. });
14. t1.start();
15. t2.start();

复制代码

可见，无需同步锁。为何？这就要涉及CountDownLatch类的源码了。当然，我们暂时不消深入了解，理解其底层逻辑即可。

看这里 → 《这一次，彻底搞懂Java中的synchronized关键字》（转发）。

大家找到【1.同步代码块】这一栏，底层逻辑相似。
2.4 使用 ReentrantLock 结合 Condition

示例：

1. Lock lock = new ReentrantLock();
2. Condition cond = lock.newCondition();
4. Thread t1 = new Thread(() -> {
5.     lock.lock();
6.     try {
7.         cond.await();
8.     } catch (InterruptedException e) {
9.         e.printStackTrace();
10.     }
11.     System.out.println("t1已唤醒");
12.     lock.unlock();
13. });
14. Thread t2 = new Thread(() -> {
15.     lock.lock();
16.     System.out.println("唤醒t1");
17.     cond.signal();
18.     lock.unlock();
19. });
20. t1.start();
21. t2.start();

复制代码

这两条代码合起来相称于同步锁：

1. lock.lock();
2. ...
3. lock.unlock();

复制代码

2.5 使用 LockSupport

示例：

1. Thread t1 = new Thread(() -> {
2.     LockSupport.park();
3.     System.out.println("t1已唤醒");
4. });
5. Thread t2 = new Thread(() -> {
6.     System.out.println("唤醒t1");
7.     LockSupport.unpark(t1);
8. });
9. t1.start();
10. t2.start();

复制代码

可见，LockSupport类不关注是否“在等待”。
最后

本文中的例子是为了方便大家理解和阐述知识点而简单举出的，旨在“阐明知识点”，简单为主，并不一定有实用性。
如果大家想要快速地掌握这些知识点，我的发起是“自测中理解”。
本文完结。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。