简介

大家都知道线程是有生命周期，但是彤哥可以认真负责地告诉你网上几乎没有一篇文章讲得是完全正确的。

常见的错误有：就绪状态、运行中状态（RUNNING）、死亡状态、中断状态、只有阻塞没有等待状态、流程图乱画等，最常见的错误就是说线程只有5种状态。

今天这篇文章会彻底讲清楚线程的生命周期，并分析synchronized锁、基于AQS的锁中线程状态变化的逻辑。

所以，对synchronized锁和AQS原理（源码）不了解的同学，请翻一下彤哥之前的文章先熟悉这两部分的内容，否则肯定记不住这里讲的线程生命周期。

问题

（1）线程的状态有哪些？

（2）synchronized锁各阶段线程处于什么状态？

（3）重入锁、条件锁各阶段线程处于什么状态？

先上源码

关于线程的生命周期，我们可以看一下 java.lang.Thread.State这个类，它是线程的内部枚举类，定义了线程的各种状态，并且注释也很清晰。

  1. public enum State {

  2. /**

  3. * 新建状态，线程还未开始

  4. */

  5. NEW,

  6.  

  7. /**

  8. * 可运行状态，正在运行或者在等待系统资源，比如CPU

  9. */

  10. RUNNABLE,

  11.  

  12. /**

  13. * 阻塞状态，在等待一个监视器锁（也就是我们常说的synchronized）

  14. * 或者在调用了Object.wait()方法且被notify()之后也会进入BLOCKED状态

  15. */

  16. BLOCKED,

  17.  

  18. /**

  19. * 等待状态，在调用了以下方法后进入此状态

  20. * 1. Object.wait()无超时的方法后且未被notify()前，如果被notify()了会进入BLOCKED状态

  21. * 2. Thread.join()无超时的方法后

  22. * 3. LockSupport.park()无超时的方法后

  23. */

  24. WAITING,

  25.  

  26. /**

  27. * 超时等待状态，在调用了以下方法后会进入超时等待状态

  28. * 1. Thread.sleep()方法后【本文由公从号“彤哥读源码”原创】

  29. * 2. Object.wait(timeout)方法后且未到超时时间前，如果达到超时了或被notify()了会进入BLOCKED状态

  30. * 3. Thread.join(timeout)方法后

  31. * 4. LockSupport.parkNanos(nanos)方法后

  32. * 5. LockSupport.parkUntil(deadline)方法后

  33. */

  34. TIMED_WAITING,

  35.  

  36. /**

  37. * 终止状态，线程已经执行完毕

  38. */

  39. TERMINATED;

  40. }

流程图

线程生命周期中各状态的注释完毕了，下面我们再来看看各状态之间的流转：

很遗憾，没有一篇文章能讲清楚线程的生命周期！_d3

怎么样？是不是很复杂？彤哥几乎把网上的资料都查了一遍，没有一篇文章把这个流程图完整画出来的，下面彤哥就来一一解释：

（1）为了方便讲解，我们把锁分成两大类，一类是synchronized锁，一类是基于AQS的锁（我们拿重入锁举例），也就是内部使用了LockSupport.park()/parkNanos()/parkUntil()几个方法的锁；

（2）不管是synchronized锁还是基于AQS的锁，内部都是分成两个队列，一个是同步队列（AQS的队列），一个是等待队列（Condition的队列）；

（3）对于内部调用了object.wait()/wait(timeout)或者condition.await()/await(timeout)方法，线程都是先进入等待队列，被notify()/signal()或者超时后，才会进入同步队列；

（4）明确声明，BLOCKED状态只有线程处于synchronized的同步队列的时候才会有这个状态，其它任何情况都跟这个状态无关；

（5）对于synchronized，线程执行synchronized的时候，如果立即获得了锁（没有进入同步队列），线程处于RUNNABLE状态；

（6）对于synchronized，线程执行synchronized的时候，如果无法获得锁（直接进入同步队列），线程处于BLOCKED状态；

（5）对于synchronized内部，调用了object.wait()之后线程处于WAITING状态（进入等待队列）；

（6）对于synchronized内部，调用了object.wait(timeout)之后线程处于TIMED_WAITING状态（进入等待队列）；

（7）对于synchronized内部，调用了object.wait()之后且被notify()了，如果线程立即获得了锁（也就是没有进入同步队列），线程处于RUNNABLE状态；

（8）对于synchronized内部，调用了object.wait(timeout)之后且被notify()了，如果线程立即获得了锁（也就是没有进入同步队列），线程处于RUNNABLE状态；

（9）对于synchronized内部，调用了object.wait(timeout)之后且超时了，这时如果线程正好立即获得了锁（也就是没有进入同步队列），线程处于RUNNABLE状态；

（10）对于synchronized内部，调用了object.wait()之后且被notify()了，如果线程无法获得锁（也就是进入了同步队列），线程处于BLOCKED状态；

（11）对于synchronized内部，调用了object.wait(timeout)之后且被notify()了或者超时了，如果线程无法获得锁（也就是进入了同步队列），线程处于BLOCKED状态；

（12）对于重入锁，线程执行lock.lock()的时候，如果立即获得了锁（没有进入同步队列），线程处于RUNNABLE状态；

（13）对于重入锁，线程执行lock.lock()的时候，如果无法获得锁（直接进入同步队列），线程处于WAITING状态；

（14）对于重入锁内部，调用了condition.await()之后线程处于WAITING状态（进入等待队列）；

（15）对于重入锁内部，调用了condition.await(timeout)之后线程处于TIMED_WAITING状态（进入等待队列）；

（16）对于重入锁内部，调用了condition.await()之后且被signal()了，如果线程立即获得了锁（也就是没有进入同步队列），线程处于RUNNABLE状态；

（17）对于重入锁内部，调用了condition.await(timeout)之后且被signal()了，如果线程立即获得了锁（也就是没有进入同步队列），线程处于RUNNABLE状态；

（18）对于重入锁内部，调用了condition.await(timeout)之后且超时了，这时如果线程正好立即获得了锁（也就是没有进入同步队列），线程处于RUNNABLE状态；

（19）对于重入锁内部，调用了condition.await()之后且被signal()了，如果线程无法获得锁（也就是进入了同步队列），线程处于WAITING状态；

（20）对于重入锁内部，调用了condition.await(timeout)之后且被signal()了或者超时了，如果线程无法获得锁（也就是进入了同步队列），线程处于WAITING状态；

（21）对于重入锁，如果内部调用了condition.await()之后且被signal()之后依然无法获取锁的，其实经历了两次WAITING状态的切换，一次是在等待队列，一次是在同步队列；

（22）对于重入锁，如果内部调用了condition.await(timeout)之后且被signal()或超时了的，状态会有一个从TIMED_WAITING切换到WAITING的过程，也就是从等待队列进入到同步队列；

为了便于理解，彤哥这里每一条都分的比较细，麻烦耐心看完。

测试用例

看完上面的部分，你肯定想知道怎么去验证，下面彤哥就说说验证的方法，先给出测试用例。

  1. public class ThreadLifeTest {

  2. public static void main(String[] args) throws IOException {

  3. Object object = new Object();

  4. ReentrantLock lock = new ReentrantLock();

  5. Condition condition = lock.newCondition();

  6.  

  7. new Thread(()->{

  8. synchronized (object) {

  9. try {

  10. System.out.println("thread1 waiting");

  11. object.wait();

  12. // object.wait(5000);

  13. System.out.println("thread1 after waiting");

  14. } catch (InterruptedException e) {

  15. e.printStackTrace();

  16. }

  17. }

  18. }, "Thread1").start();

  19.  

  20. new Thread(()->{

  21. synchronized (object) {

  22. try {

  23. System.out.println("thread2 notify");

  24. // 打开或关闭这段注释，观察Thread1的状态

  25. // object.notify();【本文由公从号“彤哥读源码”原创】

  26. // notify之后当前线程并不会释放锁，只是被notify的线程从等待队列进入同步队列

  27. // sleep也不会释放锁

  28. Thread.sleep(10000000);

  29. } catch (InterruptedException e) {

  30. e.printStackTrace();

  31. }

  32. }

  33. }, "Thread2").start();

  34.  

  35. new Thread(()->{

  36. lock.lock();

  37. System.out.println("thread3 waiting");

  38. try {

  39. condition.await();

  40. // condition.await(200, (TimeUnit).SECONDS);

  41. System.out.println("thread3 after waiting");

  42. } catch (InterruptedException e) {

  43. e.printStackTrace();

  44. } finally {

  45. lock.unlock();

  46. }

  47. }, "Thread3").start();

  48.  

  49. new Thread(()->{

  50. lock.lock();

  51. System.out.println("thread4");

  52. // 打开或关闭这段注释，观察Thread3的状态

  53. // condition.signal();【本文由公从号“彤哥读源码”原创】

  54. // signal之后当前线程并不会释放锁，只是被signal的线程从等待队列进入同步队列

  55. // sleep也不会释放锁

  56. try {

  57. Thread.sleep(1000000);

  58. } catch (InterruptedException e) {

  59. e.printStackTrace();

  60. } finally {

  61. lock.unlock();

  62. }

  63. }, "Thread4").start();

  64.  

  65. }

  66. }

打开或关闭上面注释部分的代码，使用IDEA的RUN模式运行代码，然后点击左边的一个摄像头按钮(jstack)，查看各线程的状态。

注：不要使用DEBUG模式，DEBUG模式全都变成WAITING状态了，很神奇。

很遗憾，没有一篇文章能讲清楚线程的生命周期！_等待队列_02

很遗憾，没有一篇文章能讲清楚线程的生命周期！_等待队列_03