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() {
    @Override
    public 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 一点时间进入 sleep
        System.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. 编程避坑：线程状态不当转换导致的性能问题

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

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

如何在云电脑实现虚拟应用—数据分层（应用分层）技术简介

如何在云电脑实现虚拟应用—数据分层（应用分层）技术简介

如何在云电脑实现虚拟应用—数据分层（应用分层）技术简介 近几年虚拟化市场实现了非常大的发展，桌面虚拟化在企业中应用越来越广泛，其拥有的如下优点得到大量企业的青睐： 数据安全不落地。在虚拟化环境下面数据保存在…
阅读更多...
网络安全快速入门（十）MySQL拓展操作

网络安全快速入门（十）MySQL拓展操作

10.1.0前言 前面我们已经对用户操作以及库，表操作有了基础的认识，接下来我们来在之前已经学过的一些操作进行进一步拓展，本章我们主要了解以下几个知识点： 数据库设计方法视图存储过程事务 我们开始本章的内容吧 10.2 数据库设计方…
阅读更多...
Java代理模式的实现详解

Java代理模式的实现详解

一、前言 1.1、说明 本文章是在学习mybatis框架源码的过程中，发现对于动态代理Mapper接口这一块的代理实现还是有些遗忘和陌生，因此在本文章中就Java实现代理模式的过程进行一个学习和总结。 1.2、参考文章 《设计模式》（第2版&#xff0…
阅读更多...
阿里云服务器下，部署LNMP环境安装wordpress

阿里云服务器下，部署LNMP环境安装wordpress

目录 1 LNMP部署1、简单说明2、nginx部署3、php8 安装4、mysql8安装5、配置 nginx 实现支持 PHP 程序6、安装 php 组件7、测试 2 wordpress部署1、安装2、配置 总结 1 LNMP部署 1、简单说明 首先需要明白，LNMP指的是Linux、Nginx、MySQL、PHP。而如果使用阿里云服…
阅读更多...
代码随想录—— 填充每个节点的下一个右侧节点指针（Leetcode116）

代码随想录—— 填充每个节点的下一个右侧节点指针（Leetcode116）

题目链接 层序遍历 /* // Definition for a Node. class Node {public int val;public Node left;public Node right;public Node next;public Node() {}public Node(int _val) {val _val;}public Node(int _val, Node _left, Node _right, Node _next) {val _val;left _…
阅读更多...
视频提取动图怎么制作？一个方法将视频转换gif

视频提取动图怎么制作？一个方法将视频转换gif

现在这个日益发展的科技社会，视频作为我们广泛应用的一种媒体形式，在各个领域都扮演着重要的角色。视频凭着丰富生动的内容成为传递信息的媒介。但是视频的体积也是比较大的，在使用的过程中会受到各种各样的限制。这个时候就可以使用gif在线制…
阅读更多...
根据Word文档用剪映批量自动生成视频发布抖音

根据Word文档用剪映批量自动生成视频发布抖音

手头有大量word文档，想通过剪映的AI图文成片功能批量生成视频，发布到抖音平台，简单3步即可： 第一步：把word文档或者PDF等文档转成txt文本，可以用一些软件，也可以用AI工具，具体常见文…
阅读更多...
LLM Agent智能体综述(超详细)

LLM Agent智能体综述(超详细)

前言 🏆🏆🏆在上一篇文章中，我们介绍了如何部署MetaGPT到本地，获取OpenAI API Key并配置其开发环境，并通过一个开发小组的多Agent案例感受了智能体的强大，在本文中，我们将对AI Agent…
阅读更多...
《灵摆疗法》PDF完整版阅读

《灵摆疗法》PDF完整版阅读

译者序 神奇丶快速又有效的灵摆疗法 2008年当我开始走上自己的灵性道路时就与灵摆结下了不解之缘当时我非常热衷于水晶疗愈所以疯狂地搜集各种不同的矿石学习如何将矿石 和水晶灵摆连结起来做能量疗愈后来在我开设马雅心能量课程时也会教大家如何使用水晶灵摆 …然而这两年来不…
阅读更多...
Python GUI开发- PyQt5 开发小工具环境入门

Python GUI开发- PyQt5 开发小工具环境入门

前言 常见的python开发gui的库有 Tkinter， PyQt5， wxPython等。本教程是选择PyQt5 开发桌面小工具。 环境准备 只需pip安装即可快速准备好开发环境 pip install pyqt5快速开始 创建一个空的window窗口 Qapplication()：每个GUI都必须包含…
阅读更多...
SpringBoot--@Autowired注入HttpServletRequest是否线程安全？

SpringBoot--@Autowired注入HttpServletRequest是否线程安全？

原文网址：SpringBoot--Autowired注入HttpServletRequest是否线程安全？_IT利刃出鞘的博客-CSDN博客 简介 本文用实例结合源码来说明Autowired注入HttpServletRequest是线程安全的。 SpringBoot获取HttpServletRequest有多种方式，见&#xf…
阅读更多...
免费思维13招之十二：耗材型思维

免费思维13招之十二：耗材型思维

免费思维13招之十二：耗材型思维 今天给你分享免费思维的两个子思维——相关性耗材思维和非相关性耗材思维。 相关性耗材思维，是指有一些产品的使用，需要大量的相关耗材，从而对该产品进行免费，而耗材进行资费。 举例：全世界最大的一家直销公司叫安利，它的明星产品是净水…
阅读更多...
Axure网上超市用户端APP原型 (O2O生鲜电商/买菜到家/数字零售/京东到家/抖音超市领域)

Axure网上超市用户端APP原型 (O2O生鲜电商/买菜到家/数字零售/京东到家/抖音超市领域)

作品概况 页面数量：共 100 页 源文件格式：rp格式，兼容 Axure RP 9/10，非程序软件无源代码 适用领域：O2O生鲜电商、网上超市、买菜到家、数字零售 作品特色 本作品为网上超市用户消费端Axure交互原型，属于…
阅读更多...
BUUCTF——大流量分析一、二、三题

BUUCTF——大流量分析一、二、三题

🍬 博主介绍👨‍🎓 博主介绍：大家好，我是 hacker-routing ，很高兴认识大家~ ✨主攻领域：【渗透领域】【应急响应】 【Java、PHP】 【VulnHub靶场复现】【面试分析】 🎉点赞➕评论➕收…
阅读更多...
Spring Boot：异常处理

Spring Boot：异常处理

Spring Boot 前言使用自定义错误页面处理异常使用 ExceptionHandler 注解处理异常使用 ControllerAdvice 注解处理异常使用配置类处理异常使用自定义类处理异常 前言 在 Spring Boot 中，异常处理是一个重要的部分，可以允许开发者优雅地处理应用程序中可…
阅读更多...
Spring WebFlux 初探-响应式编程-021

Spring WebFlux 初探-响应式编程-021

🤗 ApiHug {Postman|Swagger|Api...} 快↑ 准√ 省↓ GitHub - apihug/apihug.com: All abou the Apihug apihug.com: 有爱，有温度，有质量，有信任ApiHug - API design Copilot - IntelliJ IDEs Plugin | Marketplace The Nex…
阅读更多...
[HUBUCTF 2022 新生赛]ezsql

[HUBUCTF 2022 新生赛]ezsql

测试无结果 扫描目录，得到源码 找到注入点 思路：更新资料的时候可以同时更新所有密码 我们需要知道密码的字段名 爆库 nicknameasdf&age111,description(select database())#&descriptionaaa&token31ad6e5a2534a91ed634aca0b27c14a9 爆表…
阅读更多...
外网ip地址怎么获取？快解析

外网ip地址怎么获取？快解析

大家都清楚互联网是通过ip地址通信的，ip地址又分内网ip和外网ip。内网ip只能在内网使用；而外网ip作为电脑唯一标识，可在公网使用。那么外网ip地址怎么获取呢？ 外网ip是网络运营商分配给用户的。目前最常见的两种上网方式一个是拉…
阅读更多...
Muse论文精读

Muse论文精读

Muse Abstract 我们介绍了Muse，一个文本到图像的Transformer模型，它实现了最先进的图像生成性能，同时比扩散或自回归模型更有效。Muse是在离散标记空间中的掩码建模任务上进行训练的:给定从预训练的大型语言模型(LLM)中提取的文本嵌入&…
阅读更多...
【保姆级介绍下运维】

【保姆级介绍下运维】

🌈个人主页: 程序员不想敲代码啊 🏆CSDN优质创作者，CSDN实力新星，CSDN博客专家 👍点赞⭐评论⭐收藏 🤝希望本文对您有所裨益，如有不足之处，欢迎在评论区提出指正，让我们共…
阅读更多...
最新文章

Copyright @ 2022~2023