时间戳

首页 > 技术文章 > JAVA线程生命周期

JAVA线程生命周期

-ape 2022-03-13 19:10 原文

面试官：您知道线程的生命周期包括哪几个阶段？

应聘者：

线程的生命周期包含5个阶段，包括：新建、就绪、运行、阻塞、销毁。

  • 新建：就是刚使用new方法，new出来的线程；

  • 就绪：就是调用的线程的start()方法后，这时候线程处于等待CPU分配资源阶段，谁先抢的CPU资源，谁开始执行;

  • 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run方法定义了线程的操作和功能;

  • 阻塞：在运行状态的时候，可能因为某些原因导致运行状态的线程变成了阻塞状态，比如sleep()、wait()之后线程就处于了阻塞状态，这个时候需要其他机制将处于阻塞状态的线程唤醒，比如调用notify或者notifyAll()方法。唤醒的线程不会立刻执行run方法，它们要再次等待CPU分配资源进入运行状态;

  • 销毁：如果线程正常执行完毕后或线程被提前强制性的终止或出现异常导致结束，那么线程就要被销毁，释放资源;

完整的生命周期图如下：

                                

 

新建状态

我们来看下面一段代码：

1
Thread t1 = new Thread();

这里的创建，仅仅是在JAVA的这种编程语言层面被创建，而在操作系统层面，真正的线程还没有被创建。只有当我们调用了 start() 方法之后，该线程才会被创建出来，进入Runnable状态。只有当我们调用了 start() 方法之后，该线程才会被创建出来

                                                                                      

 

就绪状态

调用start()方法后，JVM 进程会去创建一个新的线程，而此线程不会马上被 CPU 调度运行，进入Running状态，这里会有一个中间状态，就是Runnable状态，你可以理解为等待被 CPU 调度的状态

1
t1.start()

用一张图表示如下：

那么处于Runnable状态的线程能发生哪些状态转变？

Runnable状态的线程无法直接进入Blocked状态和Terminated状态的。只有处在Running状态的线程，换句话说，只有获得CPU调度执行权的线程才有资格进入Blocked状态和Terminated状态，Runnable状态的线程要么能被转换成Running状态，要么被意外终止。

 

运行状态

当CPU调度发生，并从任务队列中选中了某个Runnable线程时，该线程会进入Running执行状态，并且开始调用run()方法中逻辑代码。

那么处于Running状态的线程能发生哪些状态转变？

  • 被转换成Terminated状态，比如调用 stop() 方法;

  • 被转换成Blocked状态，比如调用了sleep, wait 方法被加入 waitSet 中；

  • 被转换成Blocked状态，如进行 IO 阻塞操作，如查询数据库进入阻塞状态；

  • 被转换成Blocked状态，比如获取某个锁的释放，而被加入该锁的阻塞队列中；

  • 该线程的时间片用完，CPU 再次调度，进入Runnable状态；

  • 线程主动调用 yield 方法，让出 CPU 资源，进入Runnable状态

 

阻塞状态

Blocked状态的线程能够发生哪些状态改变？

  • 被转换成Terminated状态，比如调用 stop() 方法，或者是 JVM 意外 Crash;

  • 被转换成Runnable状态，阻塞时间结束，比如读取到了数据库的数据后；

  • 完成了指定时间的休眠，进入到Runnable状态；

  • 正在wait中的线程，被其他线程调用notify/notifyAll方法唤醒，进入到Runnable状态；

  • 线程获取到了想要的锁资源，进入Runnable状态；

  • 线程在阻塞状态下被打断，如其他线程调用了interrupt方法，进入到Runnable状态；

 

终止状态

一旦线程进入了Terminated状态，就意味着这个线程生命的终结，哪些情况下，线程会进入到Terminated状态呢？

  • 线程正常运行结束，生命周期结束；

  • 线程运行过程中出现意外错误；

  • JVM 异常结束，所有的线程生命周期均被结束。

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

  • 通用线程模型

在很多研发当中，实际应用是基于一个理论再进行优化的。所以，在了解JVM规范中的Java线程的生命周期之前，我们可以先了解通用的线程生命周期，这有助于我们后续对JVM线程生命周期的理解。

首先，通用的线程生命周期有五种，分别是：新建状态（NEW）、可运行状态（RUNNABLE）、运行状态（RUN）、休眠状态（SLEEP）、终止状态（TERMINATED）。生命流程如下图所示：

  1. 新建状态（NEW）。线程在此状态，仅仅是在编程语言层面创建了此线程，而在真正的操作系统中是没有创建的。所以，它在这个状态下是无法获得CPU的执行的权限的。
  2. 可运行状态（RUNNABLE）。线程到达此状态，意味着它已经被操作系统创建，该线程获得被CPU执行的资格，但此时还没有被CPU执行相关操作。
  3. 运行状态（RUN）。线程获得CPU的执行权限，在一个特定的时间片内执行，线程仅在这个时间片内被称为运行状态。
  4. 休眠状态（SLEEP）。当线程调用了某个阻塞API或者等待IO操作的时候，它会释放当前CPU的执行权限，进入休眠状态。此时，线程没有获取CPU执行的资格，只有当该线程被唤醒时，线程才能进入RUNNABLE状态。
  5. 终止状态（TERMINATED）。当线程完成程序任务或者出现异常的时候，它就会进入终止状态。一个线程的使命就此结束。

  • JVM线程模型

JVM中的线程模型对于上面的通用线程模型进行了一些特有的分类和合并，它们的类别如下：

  1. 新建状态（NEW） 
  2. 可运行/运行状态（RUNNABLE）
  3. 阻塞状态（BLOCK）
  4. 等待状态（WAITING）
  5. 有限等待状态（TIMED_WATING）
  6. 终止状态（TERMINATED）

而JVM中的状态结合到通用状态中可以如下图所示理解：

由上图可以看出，JVM讲运行中的线程和等待运行的线程归为一类，因为JVM不关心操作系统层面的调度，所以把这两个状态合并了。而Block、Wating、Timed_Wating三个状态在操作系统层面都为休眠状态没有区别。所以，这三种状态都没有获得CPU执行的资格。

  • 线程状态的转换

从上面的JVM线程生命周期图分析，我来说说一个线程从新建到消亡的状态转变中，到底会发生什么事情。

  1. 从NEW到RUNNABLE

这个很简单，线程在被显式声明后，在调用start()方法前，这段时间都被称为NEW状态。如下代码所示

1   Runnable task = ()-> System.out.println("线程启动");
2         //创建一个线程，线程状态为NEW状态
3         Thread thread = new Thread(task);

 

　　2.从RUNNABLE到BLOCK

从RUNNABLE到BLOCK状态的转变只有一种途径，那就是在有synchronized关键字的程序当中。当线程执行到此，没有获取到synchronized的隐式锁，线程就会从RUNNABLE被阻塞为BLOCK状态。当阻塞中的线程获取到synchronized隐式锁时，它又会转变为RUNNABLE状态。

问：当线程调用阻塞API时，它的状态会不会改变呢？ 例如我们日常说的：ServerSockt的accept()、Scanner的next()方法等。

答案是：对于JVM层面来说，调用这些方法的线程依旧在RUNNABLE状态，因为JVM对于等待CPU资源或等待IO资源并不关心，所以把他们归为RUNNABLE状态。而对于操作系统层面来说，线程则属于休眠状态。（对于较真的同学，可以通过jstack指令查看调用阻塞API是的线程是什么状态）

　　3.RUNNABLE到WATING

其中有三种场景会使线程转换为WATING状态：

  1. 在synchronized的内部，调用wait()方法。
  2. 调用Thread.join()方法。该方法的意思是，当一个A线程调用了B线程的join方法，那么A线程就必须等待B线程执行完毕，此时，A线程就为WATING状态。需要注意的是，如果是B线程自己调用自己的join方法。那么就会造成自己等待自己的局面，从而使线程无限等待。

  3. 调用LockSupport.park()方法。这个方法看上去很陌生，但是其实jdk中的并发包中的锁都是由它实现的。例如：我们日常中用到的lock.lock()方法，condition.await()方法，其底层都是通过调用这个方法运行的。

 

　　4.RUNNABLE到TIMED_WATING状态

其实从字面上就可以看出，TIMED_WATING状态与WATING状态的差别就是TIMED_WATING会在有限的时间内等待。所以，在WATING方法中的大多数方法，只要加上一个时间参数，就会触发TIMED_WATING这个状态。具体的有：

1         Thread.currentThread().join(millis);
2         Thread.sleep(millis);
3         Obj.wait(timeout);
4         LockSupport.parkNanos(Object blocker, long deadline);
5         LockSupport.parkUntil(long deadline);

 

　　5.RUNNABLE到TERMINAL状态

当线程顺利的完成run()方法中的任务，就会进入TERMINAL状态。同时，当线程抛出没有处理异常的时候，线程同样会变为TERMINAL状态。那如果业务上需要我们主动的终止线程，那应该怎么做呢？

 

  • 终止线程的正确姿势

在以往的jdk中，它提供了一些诸如：stop()、suspend()、resume()方法，这些方法都会直接把线程关闭，不给线程任何处理的机会。这样做的风险可想而知，所以这些方法早就已经被标记为过时方法，不推荐使用，我也没有详细去了解。那么，我们现在想要终止一个线程，该怎么做呢？

答案就是：通过调用thread.interrupt();方法来达到终止线程的目的。当然，并不是调用interrupt()就会关闭线程，我们通过一个图来了解一下具体的流程是怎样的。

如图所示，线程状态的不同，对于Interrupt方法的处理也不同。流程在图中已经比较清晰，我再列出几个重点：

  1. Interrupt方法仅仅是把线程是否被中断的标识设置为true。
  2. 当抛出InterruptedException时会把中断标志清除
  3. 被中断的线程状态不同，做出的响应也会不同。运行时线程需要主动检测、等待时的异常会抛出异常（这里可以类比硬件中的中断，相当于一个信号）。

  • 总结

我们在日常开发中，一旦遇到多线程的bug，分析线程dump信息是一个非常重要的手段。而了解线程运行时的状态，有助于在分析信息时正确的判断线程的状况。同样，我们可以通过jstack命令或者Java VisualVM可视化工具来查看线程的具体信息。

推荐阅读