Java线程生命周期：Java线程生命周期全景解读

1. 线程生命周期概述：不仅仅是状态转换

在多线程编程中，理解线程的生命周期对于编写有效、高效的代码至关重要。线程生命周期通常描述了线程从创建到死亡的一系列状态变化过程，但其实不仅仅局限于这些状态的简单转换。线程生命周期的理解应该考虑系统资源的分配、线程调度、同步、通信，以及在这些状态转换中所涉及的复杂机制。
在现代操作系统中，线程生命周期涉及的五个基本状态分别是：

  • 新建 (New)
  • 就绪 (Runnable)
  • 运行 (Running)
  • 阻塞 (Blocked)
  • 死亡 (Terminated)

然而，操作系统和JVM的线程调度策略、同步机制（如锁）、等待/通知模式以及线程自身的方法调用，都会对这些状态产生影响，使得线程的生命周期变得更加复杂。本文将探讨Java中线程生命周期的每个状态，并通过丰富的实例代码展示它们之间的转换是如何发生的，以及程序员需要在实际编程工作中注意哪些问题。

以下是一个基本线程生命周期的Java代码示例：

public class ThreadLifeCycleExample implements Runnable {public void run() {// 线程处于运行状态时的逻辑处理try {// 模拟线程执行任务Thread.sleep(1000);// 线程可能处于TIMED_WAITING状态，因为调用了sleep方法} catch (InterruptedException e) {// 对中断异常的处理Thread.currentThread().interrupt();}}public static void main(String[] args) throws InterruptedException {Thread thread = new Thread(new ThreadLifeCycleExample());// 在这点，线程处于 NEW 状态System.out.println("Thread state after creation: " + thread.getState());thread.start();// 启动线程后，线程处于 RUNNABLE 状态（在Java中RUNNABLE包含了就绪和运行状态）System.out.println("Thread state after calling .start(): " + thread.getState());// 主线程暂停，确保上面的线程运行Thread.sleep(100);System.out.println("Thread state after calling .sleep() in main: " + thread.getState());// 等待线程终止thread.join();System.out.println("Thread state after completion: " + thread.getState());}
}

2. 深入Java线程状态

file
线程在Java中是通过Thread类来实现的，它封装了线程的状态以及行为。根据Java线程生命周期，线程可以存在于以下几种状态之一：

  1. 新建 (NEW)
  2. 可运行 (RUNNABLE)
  3. 阻塞 (BLOCKED)
  4. 等待 (WAITING)
  5. 计时等待 (TIMED_WAITING)
  6. 终止 (TERMINATED)

这些状态在java.lang.Thread.State枚举中有定义。接下来，我们将深入分析每个状态。

2.1. NEW：线程的诞生

一个线程在被创建出来，但是还没有调用start()方法之前，处于NEW状态。此时，它被实例化但尚未开始执行。

2.2. RUNNABLE：准备运行的双面性

在Java编程中，RUNNABLE状态实际上包含了传统意义上的"可运行"和"运行"两种状态。即线程已经被启动且可以被线程调度器执行（可运行），或已经在执行了（运行）。然而，即使线程处于RUNNABLE状态，是否正在执行由操作系统的线程调度器决定。

2.3. BLOCKED与WAITING：阻塞与等待的微妙差别

BLOCKED状态通常发生在线程试图获取一个锁时，但该锁正被其他线程持有。WAITING状态发生于等待其他线程特定的通知（notification）时，例如调用了Object.wait()方法，而没有任何时间限制。

2.4. TIMED_WAITING：带有时限的挂起

线程可以通过调用一些带有指定等待时间的方法（如Thread.sleep(long millis)或Object.wait(long timeout)）进入TIMED_WAITING状态，这意味着线程在一个特定的时间之后会自动返回RUNNABLE状态。

2.5. TERMINATED：终结并非终点

一旦线程的run()方法执行完毕，或者线程被中断，它就会进入TERMINATED状态。线程一旦终结，它的生命周期就结束了，不能重新启动。

3. 详细分析线程状态转换

理解线程状态之间的转换对于管理线程生命周期至关重要。这些状态转换可能会受代码逻辑、线程管理API的使用以及操作系统调度策略的影响。在这一章节，我们将详细探讨各个转换点，并通过实际案例来演示它们是如何在Java中实现的。

3.1. 如何从NEW到RUNNABLE：线程的启动

当一个线程被创建时，它首先处于NEW状态。一旦调用了线程对象的start()方法，该线程被移动到RUNNABLE状态，并等待线程调度器的调度执行。以下是一个示例代码：

Thread thread = new Thread(new Runnable() {@Overridepublic void run() {System.out.println("Thread is running.");}
});
System.out.println("State after thread creation: " + thread.getState());  // 应打印 NEW
thread.start();
System.out.println("State after calling start(): " + thread.getState());  // 应打印 RUNNABLE

3.2. RUNNABLE与BLOCKED的拮抗：同步造成的结果

一个线程的状态从RUNNABLE变为BLOCKED通常是因为它试图获得一个已被其他线程锁定的对象锁。这里展示了如何使用synchronized关键字来演示这个转换：

public class BlockedStateDemo {private static final Object lock = new Object();public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(BlockedStateDemo::run);Thread t2 = new Thread(BlockedStateDemo::run);t1.start();t2.start();Thread.sleep(10);  // 确保线程 t1 运行起来System.out.println("State of t2 after attempting to enter synchronized block: " + t2.getState());// 应打印 BLOCKED}private static void run() {synchronized (lock) {try {Thread.sleep(100);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}}
}

3.3. RUNNABLE到WAITING的过渡：对象监视器模型

当线程需要等待其他线程执行某个特定操作时，它会进入WAITING状态。一个典型的例子是调用Object类的wait()方法：

public class WaitingStateDemo {private static final Object lock = new Object();public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(WaitingStateDemo::run);t1.start();Thread.sleep(10);  // 给 t1 时间达到 wait() 调用System.out.println("State of t1: " + t1.getState()); // 应该打印 WAITING}private static void run() {synchronized (lock) {try {lock.wait();} catch (InterruptedException e) {Thread.currentThread().interrupt();}}}
}

3.4. WAITING到TIMED WAITING的条件：时间控制的等待

与WAITING状态相似，TIMED_WAITING状态涉及一个时间的概念。当线程调用一个带有指定等待时间的方法时，它会进入此状态，例如Thread.sleep(long millis)：

public class TimedWaitingStateDemo {public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {try {Thread.sleep(5000);} catch (InterruptedException e) {Thread.currentThread().interrupt();}});t1.start();Thread.sleep(10);  // 给 t1 一点时间进入 sleepSystem.out.println("State of t1 after calling sleep(): " + t1.getState()); // 应打印 TIMED_WAITING}
}

3.5. 从RUNNABLE到TERMINATED状态：线程的结束

一旦线程的run()方法执行完毕或者它被中断，它就会进入TERMINATED状态：

public class TerminatedStateDemo {public static void main(String[] args) throws InterruptedException {Thread t1 = new Thread(() -> {// 无任务，直接退出});t1.start();t1.join(); // 等待 t1 结束System.out.println("State of t1 after it has finished execution: " + t1.getState()); // 打印 TERMINATED}
}

4. 线程状态转换的实战案例分析

在这一章节，我们将通过几个编程案例，详细展示线程状态的转换，并解释在这些状态转换中可能遇到的问题。这将帮助开发人员更好地掌握线程状态管理，并避免常见的多线程编程陷阱。

4.1. 状态转换演示：编写示例代码解释状态转换

我们将首先展示一个简单的案例，这个案例会创建多个线程，并模拟阻塞、等待和超时等待的场景，来观察和理解线程状态的转换。

示例代码：

public class ThreadStateTransitionDemo {private static final Object LOCK = new Object();public static void main(String[] args) throws Exception {// 新建一个线程，它会进行一段时间的计时等待Thread timedWaitingThread = new Thread(() -> {try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}});// 新建一个线程，它会无限期等待直到获得锁Thread waitingThread = new Thread(() -> {synchronized (LOCK) {try {LOCK.wait();} catch (InterruptedException e) {e.printStackTrace();}}});// 新建一个线程，尝试获取锁，但是会被 waitingThread 阻塞Thread blockedThread = new Thread(() -> {synchronized (LOCK) {System.out.println("Blocked Thread 获取到了锁");}});System.out.println("启动各个状态的线程...");timedWaitingThread.start();waitingThread.start();Thread.sleep(100); // 确保 waitingThread 运行并进入 waiting 状态blockedThread.start();Thread.sleep(100); // 短暂等待，让线程尝试获取锁System.out.println("TimedWaitingThread 状态: " + timedWaitingThread.getState());System.out.println("WaitingThread 状态: " + waitingThread.getState());System.out.println("BlockedThread 状态: " + blockedThread.getState());// 发起通知，让 waitingThread 退出等待状态synchronized (LOCK) {LOCK.notify();}// 等待所有线程完成timedWaitingThread.join();waitingThread.join();blockedThread.join();System.out.println("所有线程都完成了执行。");}
}

这段代码首先创建了三个线程，它们分别模拟了计时等待（timed waiting）、无限期等待（waiting）以及阻塞（blocked）三种状态。通过调用 getState() 方法，我们可以查看每个线程的状态，然后触发状态转换进行验证。

4.2. 实例解析：挖掘阻塞、等待和超时等待的场景

接下来，我们通过上面的代码来解说不同状态下的线程是如何响应的。这有助于开发者理解在并发编程中如何正确处理同步和线程协调的关键部分。

4.3. 死锁与线程生命周期的关联

最后，我们将展示一个引入死锁的示例来说明线程状态管理如果不当，可能会导致应用程序无响应的情况。死锁的情形通常涉及两个或两个以上的线程，它们彼此等待对方释放锁，但却永远不会发生，因此线程将保持阻塞状态。

示意代码：

public class DeadlockDemo {private static final Object RESOURCE1 = new Object();private static final Object RESOURCE2 = new Object();public static void main(String[] args) {new Thread(() -> {synchronized (RESOURCE1) {System.out.println("Thread 1: Locked resource 1");try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}synchronized (RESOURCE2) {System.out.println("Thread 1: Locked resource 2");}}}).start();new Thread(() -> {synchronized (RESOURCE2) {System.out.println("Thread 2: Locked resource 2");synchronized (RESOURCE1) {System.out.println("Thread 2: Locked resource 1");}}}).start();}
}

代码中，两个线程互相持有对方需要的资源，且都在等待对方释放资源。这种情况就是典型的死锁。

5. 性能监控与线程状态：工具与实践

了解和监控Java线程的状态对于确保应用程序性能至关重要。本章节将介绍几种常用的工具，这些工具可以帮助开发者监控和分析线程的行为和状态，从而进行性能优化和故障排查。

5.1. 使用JConsole监控线程状态

JConsole是Java开发者工具箱中的标准工具，它可以通过JMX（Java Management Extensions）连接到运行中的Java应用程序，提供应用程序的实时监控数据，其中包括线程的状态信息。
当您想要查看和监控线程状态时，可启动JConsole并连接到您的Java应用程序。它将提供一个线程标签页，显示所有活动线程的列表和它们当前的状态，包括锁持有情况，以及死锁探测器等有用信息。
使用JConsole监控线程状态的步骤大致如下：

  1. 启动Java应用程序，确保在启动参数中开启JMX端口。
  2. 启动JConsole并连接到相应的JMX端口。
  3. 在’线程’标签页中观察线程状态和其他关键信息。

5.2. 借助VisualVM进行线程性能剖析

VisualVM是另一款强大的监控工具，它不仅能监控线程状态，还能提供CPU和内存的实时数据，线程转储，以及性能分析（Profiler）等功能。
通过VisualVM，开发者可以很容易地捕获线程转储（thread dump），分析应用程序中的线程是如何互相作用的，识别出性能瓶颈或不必要的同步操作。
VisualVM使用的基本步骤如下：

  1. 启动VisualVM。
  2. 选择要监控的Java应用程序。
  3. 查看’线程’标签，进行线程的实时监控或者捕获线程转储。

5.3. 编程避坑：线程状态不当转换导致的性能问题

在多线程编程中，不恰当的线程状态转换可能会导致严重的性能问题，如过度的线程创建和销毁、频繁的上下文切换、死锁和资源饥饿等。开发人员需学会使用以上工具诊断这些问题，并采取适当策略来优化代码，比如正确的同步策略，合理的线程池使用，以及有效的线程通信机制等。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/702277.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Redis的集群模式——Java全栈知识（20）

Redis的集群模式——Java全栈知识（20）

1、主从模式 Redis 支持主从模式的集群搭建，这是 Redis 提供的最简单的集群模式搭建方案，目的是解决单点服务器宕机的问题。当单点服务器发生故障的时候保证 Redis 正常运行。 主从模式主要是将集群中的 Redis 节点分为主节点和从节点。然后读和写发生在…
阅读更多...
buff禁售武器箱和胶囊的原因，及游戏搬砖人该如何应对

buff禁售武器箱和胶囊的原因，及游戏搬砖人该如何应对

大家好，我是童话，相信大家都看到这个消息了，buff平台在14号中午11点左右，已经全面禁止了武器箱和胶囊，纪念包等的上架和售卖。在饰品市场直接搜索武器箱或者胶囊，是完全搜索不出来任何东西的哈。 面对这一消…
阅读更多...
平衡三进制小数详解与进制转换

平衡三进制小数详解与进制转换

标准三进制是“逢三进一，退一还三”的机制，平衡三进制与之类似，但就是偏移了一下变得对称了，平衡三进制是逢/-2进1或进T的，平衡三进制与标准三进制可以相互转换，但这样显得有点多余了，所以这里只…
阅读更多...
Nginx 7层负载均衡的搭建

Nginx 7层负载均衡的搭建

目录 负载均衡的理解 修改配置文件 测试 1. 选择在 DMZ 区测试，使用 db 服务器进行测试 2.选择在外网测试负载均衡效果 负载均衡的理解 负载均衡：load balancer，简称LB Nginx 既是一个 web 服务器软件，也是一个负载均衡软件&a…
阅读更多...
谷歌I/O 2024大会全面硬刚OpenAI

谷歌I/O 2024大会全面硬刚OpenAI

🦉 AI新闻 🚀 谷歌发布升级版Gemini机器人 竞争OpenAI ChatGPT-4 摘要：谷歌展示了升级版的 Gemini 聊天机器人，其支持实时处理视频和语音输入，并准确回答问题。此次发布时机与 OpenAI 公布 ChatGPT-4o 新模型几乎同步…
阅读更多...
在浏览器执行js脚本的两种方式

在浏览器执行js脚本的两种方式

fetch请求get 在浏览器执行http请求，可以使用fetch函数； fetch(“url”).then(response => response.text()) .then(data => console.log(JSON.parse(data)[‘status’])) .catch(error => console.error(error)) 直接返回json数据： fetch(“url”).then(response…
阅读更多...
Milvus 安装与配置

Milvus 安装与配置

一、环境准备 在安装 Milvus 之前，确保你的系统满足以下要求： 操作系统：Milvus 支持 Linux 操作系统，如 Ubuntu、CentOS 等。硬件资源：推荐使用具有足够 CPU、内存和 SSD 存储的机器。对于大规模数据集，高…
阅读更多...
在数据库中使用存储过程插入单组/多组数据

在数据库中使用存储过程插入单组/多组数据

存储过程可以插入单组数据，也可以以字符串的形式插入多组数据，将字符串中的信息拆分成插入的数据。 首先建立一个简单的数据库 create database student; use student;选中数据库之后建立一张学生表 create table stu(uid int primary key,uname varc…
阅读更多...
K8s 二进制部署 上篇

K8s 二进制部署 上篇

一 K8S按装部署方式： ① Minikube Minikube是一个工具，可以在本地快速运行一个单节点微型K8S，仅用于学习、预览K8S的一些特 性使用。 部署地址：https://kubernetes.io/docs/setup/minikube ② Kubeadmin Kubeadmin也是一个工…
阅读更多...
(done) NLP+HMM 协作，还有维特比算法

(done) NLP+HMM 协作，还有维特比算法

参考视频：https://www.bilibili.com/video/BV1aP4y147gA/?p2&spm_id_frompageDriver&vd_source7a1a0bc74158c6993c7355c5490fc600 （这实际上是 “序列标注任务”） HMM 的训练和预测如下图 训练过程：我们首先先给出一个语…
阅读更多...
【Doris的安装与部署】

【Doris的安装与部署】

1 集群规划和环境准备 Doris作为一款MPP架构的OLAP数据库，可以在绝大多数主流的商用服务器上运行。 1.1 环境要求 一般推荐使用Linux系统，版本要求是CentOS 7.1及以上或者Ubuntu 16.04及以上，这也是目前服务器市场最主流的操作系统。 操作…
阅读更多...
技艺高超的魔法师：Java运算符

技艺高超的魔法师：Java运算符

在Java编程的世界里，运算符是连接变量和表达式的关键纽带，它们使得程序能够执行计算、比较、赋值等一系列操作。 一，基本概念 1，运算符是什么？ 运算符是操作变量的符号。 2，分类 Java中的主要运算符类…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023