线程生命周期，五大状态转换分析

约定不等于承诺〃 2023-10-06 21:19 21阅读 0赞

### 一、线程生命周期 ###

一个完整的线程生命周期，要经过 `新建`（new）、`就绪`（Runnable）、`运行`（Running）、`阻塞`（Blocked）和`死亡`（Dead）5种状态。

![图片][5721fd90f62d77cecffe32d4da96485e.png]

#### 1.new阶段 ####

new阶段就是你new Thread()创建线程对象时候的阶段。

划重点了

new阶段下其实线程根本还是`不存在`的，我们只是创建了一个`Therad对象`，就和我们最常用的new关键字是一个道理。

只有当我们真正把线程启动起来的时候，此时才会在`JVM进程`中把我们的线程创建出来。

我们new了一个Thread对象之后就需要调用Thread.start()来启动线程，此时线程会从`new`阶段转换到`Runnable`阶段。

![图片][e8fc8f36876bc4bfbb5b3df9fe24d6b1.png]

#### 2. Runnable阶段 ####

只有调用Thread.start()方法才能使线程从new阶段转换到Runnable阶段。

当然我们从字面意思也可以知道此时线程是处于`可执行转状态`而不是真正的`执行中`状态了，此时的线程只能等CPU翻牌子，翻到了他才能真正的跑起来。

有些同学可能会说要是CPU一直不翻牌子咋办？严格意义上来讲，处在Runnable的线程只有两条出路，一条是线程`意外退出`，还有一条是被CPU翻牌子进入`Running`阶段。

![图片][a92a5f33fe9a188ea66aa1050fc993aa.png]

--------------------

可以打个比方:

*  `new`阶段的时候我们的线程还是`宫外`的一位`佳人`对象
 *  调用start方法之后就摇身一变成为`宫里`的一位`小主`了，也就是中间阶段`Runnable`，
 *  等到获取到`CPU调度执行权`的时候就晋升为得宠的`娘娘`了，也就是进入了`Running`阶段。可想而知，此时我们的线程娘娘一定是比宫外的佳人要复杂的多了。

![图片][20b479cd989d861266114bbb6ee48e28.png]

#### 3.Running阶段 ####

⚠️注意

有了解过这块内容的同学看到这里可能会有疑问，java线程状态中并`没有这个状态`，为什么我们在讲生命周期的时候会把这一状态单独拆分出来做讲解？为了章节内容的流畅性，这块内容的解释放到下一节去讲解，这边我们还是继续讲我们的线程生命周期。

--------------------

好的我们继续

这个阶段的线程已经获取到了CPU调度执行权，也就是说处于运行中状态了。

在该阶段中，线程可以向前或者向后发生转换：

*  由于CPU的调度器轮询导致该线程放弃执行，就会进入`Runnable`阶段。
 *  线程主动调用yield，放弃CPU执行权，就会进入`Runnable`阶段（这种方式并不是百分百生效的，在CPU资源不紧张的时候不会生效）。
 *  调用sleep、wait方法，进入`Blocked`阶段（这里讲的Blocked阶段和线程的Blocked状态需要区分开，这边讲的是一个比较广义的Blocked的阶段）
 *  进行某个阻塞的IO操作而进入`Blocked`阶段
 *  为了获取某个锁资源而加入到该锁到阻塞队列中而进入`Blocked`阶段
 *  线程执行完成或者调用stop方法或者判断某个逻辑标识，直接进入`Terminated`阶段

![图片][5646d3d53435436066ecc3e5d90ecac3.png]

#### 4.Blocked阶段 ####

进入该阶段的原因已经在Running阶段阐述过了，这里就不再说明，这里主要介绍一下处于该阶段的线程可以如何切换。

*  直接进入`Terminated`，比如调用`stop`方法或者意外死亡（`JVM Crash`）
 *  线程`阻塞`的操作结束，读取或者写入了想操作的数据进入`Runnable`状态
 *  线程完成了指定时间的`休眠`，进入`Runnable`状态
 *  Wait状态的线程被`notify`或者`notifyall`唤醒，进入`Runnable`状态
 *  获取到了`锁资源`，进入`Runnable`状态
 *  线程阻塞过程`被打断`，比如调用`interrupt`方法，进入`Runnable`状态

![0664f1c488c046eea80eafe50aba6dd5.gif][]

#### 5.Terminated状态 ####

`Terminated`状态是一个线程的最终状态，在该状态中线程不会切换到其他任何状态。

线程进入`Terminated`状态意味着线程整个生命周期结束了，进入Terminated状态的方式有以下`三种`：

*  线程正常结束
 *  线程意外结束
 *  JVM Crash

### 线程生命周期和java线程状态对应：源码分析 ###

![图片][171a18c9bec9321f2a6d438eb9f30bfe.png]

请同学们先找到java.lang.Thread.State这个枚举类。

public enum State {
    
      // 新建，未调用start方法
      new,
      
      // 包含两种状态：就绪状态、运行状态
      Runnable,
      
      // 阻塞
      Blocked,
      
      /**
       * 等待态
       * 3种情况调用后会导致线程处于这个状态：
       * 1.Object.wait
       * 2.Thread.join
       * 3.LockSupport.park
       * 等待态的线程会等待其他线程执行特定的操作
       * 例如一个线程调用了Object.wait之后进入等待态，另一个线程调用Object.notify或Object.notifyAll可以将其唤醒，被唤醒的线程需要获取对象的锁才能恢复执行
       * 调用Thread.join会等待指定的线程终止
       */
      waiting,
      
      /**
       * 超时等待态
       * 线程等待指定的时间再执行
       * 5种情况调用后会导致线程处于这个状态：
       * 1.Thread.sleep
       * 2.Object.wait 传入等待时长
       * 3.Thread.join 传入等待时长
       * 4.LockSupport.parkNanos
       * 5.LockSupport.parkUntil
       */
      timed_waiting,
      
      // 终止，线程执行完毕
      Terminated;
    }

可以看到这边state枚举类包含有`6种线程状态`，根据说明我们一一来解读这六个状态。

new状态 = new阶段

* <li>{@link #new} 
 * A thread that has not yet started is in this state.
 * </li>

源码清楚地说明了`new状态`就是一个线程`刚刚被创建`，但是还没有启动地时候所处的状态，这个和我们上一小节中地new阶段能够对应起来这里就不多说了。

（2）Runnable状态 = Runnable阶段+Running阶段

* <li>{@link #Runnable} 
 * A thread executing in the Java virtual machine is in this state.
 * </li>

这段的说明意思是在java虚拟机中`执行的线程`所处的状态称之为`Runnable`。

也就是说我们上一节中分开讲解的`Runnable`阶段和`Running`阶段在线程状态中来看统一都称之为`Runnable`状态。

之所以我们在生命周期划分的时候把这两个状态拆分开来看是因为这两个状态差别还是很大的，`Running`状态的线程比`Runnable`状态的线程`更加复杂`一些。

Blocked状态+waiting状态+timed\_waiting状态 = Blocked阶段

/*
  * <li>{@link #Blocked} 
  *     A thread that is blocked waiting for a monitor lock
  *     is in this state.
  *     </li>
  * <li>{@link #waiting} 
  *     A thread that is waiting indefinitely for another thread to
  *     perform a particular action is in this state.
  *     </li>
  * <li>{@link #TIMED_waiting} 
  *     A thread that is waiting for another thread to perform an action
  *     for up to a specified waiting time is in this state.
  *     </li>

源码中对于这三个状态对叙述是这样的

`Blocked`:等待获取监视器锁而进入阻塞队列的线程所处的状态

`waiting`：无限期等待另一线程执行特定操作的线程处于此状态。

`TIMED_waiting`：等待另一线程执行操作的线程在指定的等待时间内处于此状态。

我们还是通过源码中对于state枚举值的描述来进入主题。state中对于Blocked状态的描述如下：

/**
       * Thread state for a thread blocked waiting for a monitor lock.
       * A thread in the blocked state is waiting for a monitor lock
       * to enter a synchronized block/method or
       * reenter a synchronized block/method after calling
       * {@link Object#wait() Object.wait}.
       */
      Blocked

源码中对于`Blocked`这一状态的叙述是这样的，线程在等待获取一个`monitor lock`的时候该线程就是处于`Blocked`。

说通俗一点就是`被synchronized`关键字描述的`同步块`或者`方法`，此时`其他线程`想要`获取`这个被描述的同步块或者方法的时候。

这个线程就会进去等待获取monitor lock，也就是进入到Blocked状态。这里的关键是`monitor lock`监视锁。

`唤醒方式`是目标监视锁monitor lock`主动释放`，这时候我们去竞争这个监视锁并成功之后。

**「waiting状态」**

/**
 * Thread state for a waiting thread.
 * A thread is in the waiting state due to calling one of the
 * following methods:
 * <ul>
 *   <li>{@link Object#wait() Object.wait} with no timeout</li>
 *   <li>{@link #join() Thread.join} with no timeout</li>
 *   <li>{@link LockSupport#park() LockSupport.park}</li>
 * </ul>
 *
 * A thread in the waiting state is waiting for another thread to
 * perform a particular action.
 *
 * For example, a thread that has called <tt>Object.wait()</tt>
 * on an object is waiting for another thread to call
 * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
 * that object. A thread that has called <tt>Thread.join()</tt>
 * is waiting for a specified thread to terminate.
 */
 waiting

这里给我们描述了哪些情况下我们的线程会进入`waiting`状态，分别是调用`Object.wait`、`Thread.join`和`LockSupport.park`三个API接口才会进入waiting状态。

`唤醒方式`是等待其他线程完成自己逻辑之后，调用`notify`或者`notiffyall`唤醒处于`waiting`状态的线程。

Terminated状态 = Terminated阶段

到这里同学们应该已经清楚了`线程生命周期`以及`各个阶段`之间的转换，同时明白了`不同阶段的生命周期`所对应的`java线程状态`。

### 线程相关方法 ###

public class Thread{
        // 线程的启动
        public void start(); 
        // 线程体
        public void run(); 
        // 已废弃
        public void stop(); 
        // 已废弃
        public void resume(); 
        // 已废弃
        public void suspend(); 
        // 在指定的毫秒数内让当前正在执行的线程休眠
        public static void sleep(long millis); 
        // 同上，增加了纳秒参数
        public static void sleep(long millis, int nanos); 
        // 测试线程是否处于活动状态
        public boolean isAlive(); 
        // 中断线程
        public void interrupt(); 
        // 测试线程是否已经中断
        public boolean isInterrupted(); 
        // 测试当前线程是否已经中断
        public static boolean interrupted(); 
        // 等待该线程终止
        public void join() throws InterruptedException; 
        // 等待该线程终止的时间最长为 millis 毫秒
        public void join(long millis) throws InterruptedException; 
        // 等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒
        public void join(long millis, int nanos) throws InterruptedException; 
    }

**文末福利  
可以加小新老师vx免费获取【Java高清路线图】和【全套学习视频和配套资料】**  
![f4491675950d47c2b8bb4a9f936f1550.png][]

[5721fd90f62d77cecffe32d4da96485e.png]: https://img-blog.csdnimg.cn/img_convert/5721fd90f62d77cecffe32d4da96485e.png
[e8fc8f36876bc4bfbb5b3df9fe24d6b1.png]: https://img-blog.csdnimg.cn/img_convert/e8fc8f36876bc4bfbb5b3df9fe24d6b1.png
[a92a5f33fe9a188ea66aa1050fc993aa.png]: https://img-blog.csdnimg.cn/img_convert/a92a5f33fe9a188ea66aa1050fc993aa.png
[20b479cd989d861266114bbb6ee48e28.png]: https://img-blog.csdnimg.cn/img_convert/20b479cd989d861266114bbb6ee48e28.png
[5646d3d53435436066ecc3e5d90ecac3.png]: https://img-blog.csdnimg.cn/img_convert/5646d3d53435436066ecc3e5d90ecac3.png
[0664f1c488c046eea80eafe50aba6dd5.gif]: https://img-blog.csdnimg.cn/0664f1c488c046eea80eafe50aba6dd5.gif
[171a18c9bec9321f2a6d438eb9f30bfe.png]: https://img-blog.csdnimg.cn/img_convert/171a18c9bec9321f2a6d438eb9f30bfe.png
[f4491675950d47c2b8bb4a9f936f1550.png]: https://img-blog.csdnimg.cn/f4491675950d47c2b8bb4a9f936f1550.png