Java线程的生命周期,终止与复位

面试复习题--RN面试 考察点:热更新方案的深度理解,选型能力,实战落地经验。答题思路主流热更新方案对比。 阅读详情

Thread生命周期

生命周期概述

Java的线程状态描述放在 Thread 类里面的枚举类 State 中.总共包含了6中状态(从出生到死亡)。

public enum State {
    /**
     * 尚未启动的线程的线程状态 (没有start)
     */
    NEW,

    /**
     * 可运行线程的线程状态,是可以运行的线程状态(并不是在运行)
     * 这个状态在Java虚拟机中进行,但它可能等待来自操作系统的其他资源,比如CPU。
     * 内部包含了两个状态 【RUNNING】,【READY】这两个状态是可以互相流转的
     * 调用了start后线程就处于 READY 状态 ,等待操作系统分配CPU时间片,分配后进入 RUNNING 状态。
     * 当调用 yield() 方法后,只是谦让的允许当前线程让出 CPU ,但是不一定让,由操作系统决定,如果让      * 了当前线程就会进入 READY 状态,等待系统分配CPU时间片再次进入 RUNNING 状态。
     */
    RUNNABLE,

    /**
     * 阻塞状态。
     * 线程阻塞,等待监视器锁的状态,获取监视器锁后会进入 RUNNABLE  状态
     * 当发生线程锁竞争状态下,没有获取到锁的线程会被挂起进入阻塞状态,比如synchronized锁。
     */
    BLOCKED,

    /**
     * 等待线程的线程状态
     * 线程调用以下方法会处于等待状态:Object.wait()不超时、Thread.join()不超时等方法
     * 一个处于等待状态的线程正在等待另一个线程执行特定动作,例如:
     * 一个线程调用了Object.wait()方法在一个对象上正在等待另一个线程调用Object.nofify()或者
     * Object.nofifyAll()方法开启那个对象
     * 一个调用了Thread.join()方法的线程正在等待指定线程终止
     */
    WAITING,

    /**
     * 具有指定等待时间的等待线程的线程状态,调用一下方法会处于这个状态: Object.wait() 超时、          * Thread.join()超时 Thread.sleep(long) 等方法 
     */
    TIMED_WAITING,

    /**
     * 已终止线程的线程状态
     * 线程执行完毕或者发生异常终止执行
     */
    TERMINATED;
}

线程生命周期流程图

线程生命周期测试

public class ThreadStatusDemo {
    public static void main(String[] args) throws InterruptedException {
        // 测试 NEW RUNNABLE TERMINATED
        Thread terminated_thread = new Thread(() -> {
            long start = System.currentTimeMillis();
            // 运行三秒 ,打印TERMINATED_THREAD线程runnable状态
            while (System.currentTimeMillis()-start<3000){}
        }, "TERMINATED_THREAD");
        // NEW
        Thread.State state = terminated_thread.getState();
        System.out.println(terminated_thread.getName()+" :state = " + state);

        terminated_thread.start();
        TimeUnit.SECONDS.sleep(1);
        // RUNNABLE
        Thread.State state1 = terminated_thread.getState();
        System.out.println(terminated_thread.getName()+"state1 = " + state1);

        TimeUnit.SECONDS.sleep(5);
        Thread.State state2 = terminated_thread.getState();
        // TERMINATED
        System.out.println(terminated_thread.getName()+"state2 = " + state2);

        // RUNNABLE
        new Thread(() -> {
            while (true) {

            }
        }, "Runnle_Thread").start();


        // TIMED_WAITING
        new Thread(() -> {
            while (true) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Time_Waiting_Thread").start();
        // WAITING
        new Thread(() -> {
            while (true) {
                synchronized (ThreadStatusDemo.class) {
                    try {
                        ThreadStatusDemo.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "Waiting_Thread").start();

        // 这两个看谁先抢占到cpu获得锁,另一个就blocked
        // timed_waiting
        new Thread(new BlockedDemo(), "Blocke01_Thread").start();
        // blocked
        new Thread(new BlockedDemo(), "Blocke02_Thread").start();

    }

    static class BlockedDemo extends Thread {
        @Override
        public void run() {
            synchronized (BlockedDemo.class) {
                while (true) {
                    try {
                        TimeUnit.SECONDS.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

启动线程

java中的启动

Java 启动一个线程调用 start 方法,start方法内部调用了 start0() native方法。

public synchronized void start() {
    . . .
    boolean started = false;
    try { 
        // 调用native方法
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

这个测试是为了验证上图的正确性,只贴了部分.

Hotspot中的启动

查看指引

在 jvm.cpp 找到 JVM_StartThread 方法。发现是先创建个 JavaThread 作为本地线程然后启动这个本地线程(借助os【thread.cpp】,因为jvm是跨平台的,这里是以linux-os为示例)

JVM_ENTRY(void, JVM_StartThread(JNIEnv* env, jobject jthread))
  JVMWrapper("JVM_StartThread");
  JavaThread *native_thread = NULL;
  bool throw_illegal_thread_state = false;
  {
    MutexLocker mu(Threads_lock);
    
    if (java_lang_Thread::thread(JNIHandles::resolve_non_null(jthread)) != NULL) {
      throw_illegal_thread_state = true;
    } else {
      jlong size =
             java_lang_Thread::stackSize(JNIHandles::resolve_non_null(jthread));
      size_t sz = size > 0 ? (size_t) size : 0;
      // 先创建一个JavaThread
      native_thread = new JavaThread(&thread_entry, sz);
      if (native_thread->osthread() != NULL) {
        native_thread->prepare(jthread);
      }
    }
  }
  if (throw_illegal_thread_state) {
    THROW(vmSymbols::java_lang_IllegalThreadStateException());
  }
  assert(native_thread != NULL, "Starting null thread?");
  if (native_thread->osthread() == NULL) {
    delete native_thread;
    if (JvmtiExport::should_post_resource_exhausted()) {
      JvmtiExport::post_resource_exhausted(
        JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR | JVMTI_RESOURCE_EXHAUSTED_THREADS,
        "unable to create new native thread");
    }
    THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(),
              "unable to create new native thread");
  }
  // 然后启动这个本地线程 thread.cpp
  Thread::start(native_thread);
JVM_END

JavaThread 创建线程

JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
  Thread()
#if INCLUDE_ALL_GCS
  , _satb_mark_queue(&_satb_mark_queue_set),
  _dirty_card_queue(&_dirty_card_queue_set)
#endif // INCLUDE_ALL_GCS
{
  if (TraceThreadEvents) {
    tty->print_cr("creating thread %p", this);
  }
  initialize();
  _jni_attach_state = _not_attaching_via_jni;
  set_entry_point(entry_point);
  os::ThreadType thr_type = os::java_thread;
  thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :
                                                     os::java_thread;

// 调用os(操作系统)创建个线程            
  os::create_thread(this, thr_type, stack_sz);
  _safepoint_visible = false; 
   . . .
}

thread.cpp 启动线程

// tips: 启动线程的方法
void Thread::start(Thread* thread) {
  trace("start", thread);
  // Start is different from resume in that its safety is guaranteed by context or
  // being called from a Java method synchronized on the Thread object.
  if (!DisableStartThread) {
    if (thread->is_Java_thread()) {
      // Initialize the thread state to RUNNABLE before starting this thread.
      // Can not set it after the thread started because we do not know the
      // exact thread state at that time. It could be in MONITOR_WAIT or
      // in SLEEPING or some other state.
      // tips:启动之后设置线程的状态为 可运行状态 RUNNABLE
      java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),
                                          java_lang_Thread::RUNNABLE);
    }
    // 借助操作系统启动线程
    os::start_thread(thread);
  }
}

线程中断与复位

不要使用stop方法

线程的终止不要简单的调用 stop 方法,这个方法和其他的线程控制方法( suspend , resume )一样都是过期了不建议使用的,这些方法都是不安全的。 例如 stop() 方法在结束一个线程的时候并不保证线程资源的正常释放,因此可能导致出现一些不确定的状态。 按照人类逻辑来理解:T1线程调用方法修改T2线程的状态,但是T2现在在做什么T1是不清楚的,所以强制他关闭就是不安全的,就好比在 Linux 中使用 kill -9 杀掉一个进程。

使用interrupt方法

interrupt() 方法只是修改了被中断线程的中断标志 ,并没有做什么过分的事儿。就像平时写代码的时候修改某对象的标志,对象自己通过标志类决定执行什么逻辑。这里也是一样, interrupt() 方法修改中断标志,被中断的线程,自己决定做什么事儿(中断或者不中断都是被中断线程自己决定的,外部只是通知他,不是强迫他)。追一下源码。

1.Java调用 interrupt 方法

2.通过指引找到 jvm.cpp#JVM_Interrupt 方法

thread.cpp interrupt 借用操作系统。直接通过系统调用 interrupt
void Thread::interrupt(Thread* thread) {
  trace("interrupt", thread);
  debug_only(check_for_dangling_thread_pointer(thread);)
  // tips: 调用操作系统的interrupt方法
  os::interrupt(thread);
}

这里还是以os_linux.cpp为例最终调用osthread的set_interrupted修改状态

这里就印证了上方的 Thread.interrupt() 只是修改了线程的一个标志位 ,并没有做什么过分的事儿。

线程的复位

interrupted 与 isInterrupted

这两个放在一起是因为他们底层都是调用的同一个native方法 isInterrupted() 只是给了不同的入参。 再就是,有过面试官问到他两的区别,所以干脆放在一起。首先说结论 , isInterrupted() 会返回线程的中断状态, interrupted() 不仅会返回中断状态,而且如果线程处于状态状态还会将线程终端状态复位(清除中断状态)。

os_linux.cpp的 is_interrupted() 方法印证了上面说的 isInterrupted() 会返回线程的中断状态, interrupted() 不仅会返回中断状态,而且如果线程处于状态状态还会将线程终端状态复位(清除中断状态)。

其他的线程复位

在 Java 中只要抛出了 InnterruptException 异常的方法都对线程进行了复位。先理顺下为什么要这么做:查看下基本上抛出 InnterruptException 异常的方法都是线程阻塞方法,比如 sleep() , wait() , join() 。这类方法执行后线程会处于 TIMED_WAITING 或者 WAITING 状态,处于这类状态的线程是不受控的(线程丧失了对自己的主导,需要其他的线程唤醒,或者阻塞时间到达才能拥有自己的主导权),这个时候线程中断,线程自己却没办法处理。甚至可能永远等不到释放而无法执行中断。所以,在线程是中断状态下,执行方法让线程阻塞,就要抛出一个异常告诉外界 ,我现在是阻塞状态,并且将中断标记复位,方便外界进行处理(例如中断线程的执行或者继续阻塞方法),相当于给了外界一个改变线程状态的入口。 以 sleep() 为例追踪下源码:

通过指引找到 jcm.cpp#JVM_Sleep

方法入口就直接判断线程的中断状态了 , is_interrupted() 上面介绍过了,参数为 true 就是清除中断标志并且返回清除之前的中断状态。这里线程是中断状态的就直接抛出 InnterruptException sleep interrupted 异常了。

Unreal5 从入门到精通之 如何实现 离线语音识别 本文介绍了如何使用离线语音识别插件 Offline Speech Recognition 进行本地语音转文本处理。该插件支持离线运行,用户可以通过下载并运行语言服务器(如 Vosk)来处理语音数据。文章详细说明了如何设置语言服务器、下载语言模型,并在虚幻引擎(UE)项目中配置麦克风和语音捕获。此外,还介绍了如何将 SoundWave 作为输入,以及如何通过节点将语音数据发送到语言服务器进行处理。最后,提供了相关文档链接以供进一步参考。 阅读详情

相关推荐

AI大模型学习(14)AI 小白入门!用 OpenCV+Python 打造人体姿态识别系统,超详细教程来了

这篇教程介绍了如何使用Python+OpenCV+MediaPipe搭建入门级人体姿态识别系统。主要内容包括:人体姿态识别的应用场景(如健身APP、体感游戏)、开发环境搭建(安装Python、OpenCV和MediaPipe库)、核心代码实现(通过30行代码完成摄像头姿态检测),以及进阶功能开发(深蹲动作纠正算法和PPT体感控制器)。教程详细解析了MediaPipe的BlazePose模型架构和33个关键点的生理学意义,并提供了多线程优化等性能提升方案。该项目适合AI初学者实践,无需复杂算法即可实现实时人体

isoft888的专栏,致力于C#/python分享物联网、大数据,神经网络的等领域,欢迎讨论交流! 1557

Java窗口重置

1、找到java界面中的Windows 2、右击进去按图下步骤进入 3、确定重置串口

weixin_46365028的博客 2567

解读区块链在制药和物流管理中具备的优势

供应链透明度是建立药品弹性供应链的关键,如何更好地促进端到端的透明度,促进合作伙伴和消费者之间的信任度是当前医药和物流行业高管们关注的话题,区块链技术可以很好的帮助他们。 链集市 · 让区块链落地更简单 《区块链行业观察》专栏·第 31 篇 作者丨Shams Rahman 图片丨来源于网络 作者介绍:本文作者为Shams Rahman教授,是RMIT大学商业IT和物流学院的供应链管理教授、研究与创新部门副主任。本文中文版本由链集市团队编译整理,英文版权归原作者所有,中文转载请联系编译。 新冠肺炎疫情的爆发

CECBC的博客 626

线程中断/恢复的几种方式

Ø 该线程调用Thread.sleep() 进入中断状态必须经过规定的毫秒数才能从中断状态进入可运行状态 Ø 该线程进行了IO操作 而进入中断状态必须等待IO操作完成,才能 进入可运行状态 Ø 该线程调用了其它线程的join()方法,而使自己进入中断状态必须等待调用的线程执行完,才能进入可运行状态 Ø 该线程试图访问被另一个线程锁住的对象 而进入中断状态必须等待另一个线程释放对象锁,该线程才

Java教程 2705

Apache Kafka Connect任意文件读取漏洞(CVE-2025-27817)

由于Apache Kafka客户端未对用户输入进行严格验证和限制,未经身份验证的攻击者可通过构造恶意配置读取环境变量或磁盘任意内容,或向非预期位置发送请求,提升REST API的文件系统/环境/URL访问权限。(CVE-2025-27817)

iSee857的博客 2026

【机器人技术基础】MATLAB Robotics Toolbox PUMA560 运动学正逆解

机器人技术基础实验2报告 1. 实验目的和要求 2. 实验手段 2.1 实验原理 2.2 函数详解 3. 实验主要内容 4. 实验结果和分析 4.1 正运动学求解 例1 例2 4.2 逆运动学求解 例1 例2 1. 实验目的和要求 掌握常见形式的机器人的D-H坐标系建立方法、运动学建模; 正逆运动学分析与求解; 使用Robotics Toolbox对直角坐标机器人、圆柱坐标机器人、球坐标机器人、PUMA560其中之一建立运动学模型,正逆求解和仿真。 2. 实验手段 2.1

【人工智障 | 计算鸡视觉 | 机器孩】 1万+

线程的状态及相关问题

工作中大家肯定都碰到过多线程,那么对于线程的几种状态你了解吗?首先,你得弄清楚线程有几种状态,然后才是怎么对各种状态的了解。 线程有6种状态,分别为NEW(初始),RUNNABLE(运行),WAITING(等待),TIME_WAITING(超时等待),BLOCKED(阻塞),TERMINATED(终止)。 一、NEW(初始) 一个线程创...

xiaoye的博客 1200

“华为杯“第十四届中国研究生数学建模竞赛-E题:多波次导弹发射中的规划问题(续)(附MATLAB代码实现)

将最长暴露时间的发射装置按照“优先隐蔽于转载地”,即增加该种发射装置的隐蔽时长,从而达到缩短最长暴露时间的目的。8.2 模型建立。

getusushu的博客 300

Java笔记-线程中断

线程中断

虽然但是 1089

锂电池SOC估计 | 基于LSTM长短期记忆神经网络的锂电池SOC估计(附matlab完整代码)

锂电池SOC估计 | 基于LSTM长短期记忆神经网络的锂电池SOC估计(附matlab完整代码)

前程算法屋的博客 1025

【图像超分】论文复现:CVPR 2024 | 轻量化超分 | 窗口注意力改进 | CAMixerSR的Pytorch源码复现,跑通源码,获得指标和超分结果,计算复杂度,架构梳理拆解,逐行注释!

本文介绍了超分辨率重建方法CAMixerSR的代码实现与运行指南。文章亮点包括:完整跑通源码获取PSNR/SSIM指标和可视化结果;详细解析模型架构与关键代码注释,帮助快速复现基线模型。实验部分提供了测试配置文件和训练设置说明,支持2K/4K/8K大图像超分和x2/x4轻量化超分。环境依赖PyTorch和BasicSR框架,数据集包含DIV2K等常用基准。测试结果与论文指标一致,可视化输出保存至指定目录。训练配置可自定义数据集路径、GPU数量等参数。该实现突出了CAMixerSR在降低W-MSA复杂度方面的

主要更新底层视觉(去噪、超分等)相关的科研内容,形式为【论文精读】+【论文复现】 441

Java并发编程|第二篇:线程生命周期

文章目录1.线程的状态2.线程生命周期3.状态测试代码4.线程终止4.1 线程执行完成4.2 interrupt5.线程复位5.1interrupted5.1抛出异常6.参考 1.线程的状态 jdk源码中Thread类中有个State的枚举类,表示线程运行中的所有状态 NEW Thread state for a thread which has not yet started. 创建线程...

谢文峰的博客 371

GStreamer —— 2.1、Windows搭建GStreamer环境,Qt加载GStreamer库后运行 - “教程1:Hello world!“(附:完整源码)

GStreamer —— 2、Windows搭建GStreamer环境,Qt加载GStreamer库后运行"教程1:Hello world!"

798

敞开心扉,一起聊聊Java多线程

敞开心扉,一起聊聊Java多线程(结尾有福利~)今天!我们来聊一聊多线程~我们都知道,不论在是面试还是工作中,多线程都是一些老生常谈的话题,相信正在阅读得你,脑海中已然浮现出多线程的...

JAVA高级架构 398

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

线程的几个方法

进程的最小执行单元,一个程序中不同的执行路径,就是多个线程。 方法调用和线程调用: run方法级别调用: 调用run,本方法和run方法是同一个线程 start方法线程级别调用 本地方法继续执行,同时会产生一个分支线程来执行start(线程中的run方法) start方法最终会调用run方法,start调用操作系统创建线程,然后由操作系统启动,状态为RUNNABLE,然后回调我们重写的run方法。 线程是cpu调度的,cpu没有线程的概念,自身是死循环,不断的从内存中获取指令然后运行,没有就歇着。 方法1:

GiantCrocodile的博客 850

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

java多线程与并发原理学习笔记(一)——java线程初步认识

java线程的创建以及启动和停止的方法

飞!!!的博客 473

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

Java 并发理解

并发 1、线程的生命周期 public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; } 在 Thread 类中有一枚举类 State 定义了...

qq_40293674的博客 291

高并发

Doug Lea 并发大师 学习方法: 场景-需求-解决方案-应用-原理 进程的生命周期:创建-销毁 Java中如何运用线程: 1,Runnable接口 2,Thread类(本质上是实现了Runnable接口)--使用较少,对资源不可控 3,ThreadPool线程池 --实际运动较多,风险(如 死锁,上下文切换等) 4,Callable/Future 带返回值的 ...

qidaorenzhe的博客 183

多线程java_敞开心扉,一起聊聊Java多线程

敞开心扉,一起聊聊Java多线程今天!我们来聊一聊 多线程 ~我们都知道,不论在是面试还是工作中,多线程都是一些老生常谈的话题,相信正在阅读得你,脑海中已然浮现出多线程的相关知识,那么,我们来一起回顾下吧 ~注意:本片博文前面内容重点在于回顾,后面内容重点讲解线程的生命周期以及线程的源码剖析一、线程的实现方式继承Thread类,重写run方法实现Runnable接口,重写run方法实现Callab...

weixin_39900468的博客 80

线程的终止与复位

线程的终止与复位

qq_41490913的博客 255

学习笔记(33):第1章 分布式基础之并发编程-了解多线程的意义和使用(下)

1. 线程安全性分析,主要内容包括原子性、可见性、有序性等分析。以及Atomic包; CAS算法、Synchronized、Lock、Happens-before等。 2. 线程的安全性手段,ThreadLocal、同步容器、并发容器、J.U.C包等 3. AQS以及其他J.U.C组件,如CountDownLatch、Semaphore、CycliBarrier、ReentrantLock ...

qq_28500837的博客 139

并发编程 - Java线程的一大堆

一、通用的线程生命周期 1、初始状态:线程被创建,但是还允许被分配cpu执行。 2、可运行状态:线程可以分配cpu执行。 3、运行状态:线程正在被cpu执行。 4、休眠状态:运行的时候,如果被阻塞或者等待某个事件,就会从运行状态转为休眠状态,同时释放cpu资源,如果等到了事件,则会转为可运行状态; 5、结束状态:线程运行完成或者出现异常。 二、通用的线程生命周期 ...

cfy1024的博客 218

java并发编程的基础

1.1.1. java并发编程的基础 1.1.1.1. 并发的发展历史 1.1.1.2. 线程的应用 1.1.1.2.1. 如何应用多线程 1继承Thread类 2实现Runnable接口 3使用ThreadPool/ExecutorService 4 Callable/Future实现带返回结果的多线程 1.1.1.2.2. 继承Thread类创建线程 Thread类本质上是实现了Runnabl...

czl315的博客 176
上一篇: Casbin访问控制框架入门详解及Java案例示范
下一篇: 详细讲解 —— 多线程初阶(一)认识线程(Java EE初阶)
javaYY_
博客等级 码龄4年 148粉丝 69原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值