线程是Java并发编程的核心执行单元，理解其生命周期与状态转换机制，以及interrupt()、wait()、notify()、join()等核心方法的底层原理，是编写高效、稳定并发程序的基础。

一、Java线程的生命周期与状态转换

枚举定义，共包含6种状态，这些状态在特定条件下会相互转换，形成完整的生命周期流转。

方法启动。此时线程仅在JVM内存中存在，未分配CPU时间片，也未开始执行。

方法启动，处于可执行状态。该状态包含两种子状态：

Java将这两种子状态统一称为RUNNABLE，因为线程在Ready和Running之间的切换由JVM线程调度器控制，应用程序无法直接感知。

线程因等待监视器锁（synchronized）而被阻塞。当线程尝试进入被其他线程持有的synchronized块/方法时，会进入该状态，直到获取到锁才会转换回RUNNABLE。

线程进入无限期等待状态，需等待其他线程执行特定操作（如notify()/notifyAll()）才能被唤醒。进入该状态的场景包括：

线程进入有时限的等待状态，超过指定时间后会自动唤醒，或在等待时间内被其他线程唤醒。进入该状态的场景包括：

线程执行完毕，生命周期结束。线程进入该状态的原因包括：

二、核心方法的底层原理与正确使用场景

，而非强制终止线程。线程需要主动检查中断标志位并响应中断，这是一种协作式的中断机制。

当线程处于WAITING或TIMED_WAITING状态时，调用interrupt()会抛出

，因此在捕获该异常后，通常需要重新设置中断标志位，以便上层逻辑感知。

interrupt()主要用于优雅地停止线程，避免使用已废弃的

方法（该方法会强制终止线程，导致资源未释放、数据不一致等问题）。

package com.jam.demo;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class InterruptDemo implements Runnable {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                Thread.sleep(1000);
                log.info("线程正在执行任务");
            } catch (InterruptedException e) {
                log.info("捕获到InterruptedException，重置中断标志位");
                Thread.currentThread().interrupt();
            }
        }
        log.info("线程响应中断，结束运行");
    }
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new InterruptDemo(), "ken-interrupt-thread");
        thread.start();
        Thread.sleep(3500);
        log.info("主线程调用interrupt()中断子线程");
        thread.interrupt();
    }
}

2.2 wait()、notify()、notifyAll()：线程协作

关键字配合使用，核心是基于对象的监视器（Monitor）实现线程间的等待/通知机制。

主要用于实现线程间的协作，如生产者-消费者模式、Future任务实现等。

package com.jam.demo;
import lombok.extern.slf4j.Slf4j;
import java.util.LinkedList;
import java.util.Queue;
@Slf4j
public class ProducerConsumerDemo {
    private static final int QUEUE_CAPACITY = 5;
    private final Queue<Integer> queue = new LinkedList<>();
    public void produce() throws InterruptedException {
        synchronized (queue) {
            while (queue.size() == QUEUE_CAPACITY) {
                log.info("队列已满，生产者线程等待");
                queue.wait();
            }
            int product = (int) (Math.random() * 100);
            queue.offer(product);
            log.info("生产者生产产品：{}，当前队列大小：{}", product, queue.size());
            queue.notifyAll();
        }
    }
    public void consume() throws InterruptedException {
        synchronized (queue) {
            while (queue.isEmpty()) {
                log.info("队列为空，消费者线程等待");
                queue.wait();
            }
            int product = queue.poll();
            log.info("消费者消费产品：{}，当前队列大小：{}", product, queue.size());
            queue.notifyAll();
        }
    }
    public static void main(String[] args) {
        ProducerConsumerDemo demo = new ProducerConsumerDemo();
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    demo.produce();
                    Thread.sleep(400);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "ken-producer");
        Thread consumer1 = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    demo.consume();
                    Thread.sleep(700);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "ken-consumer-1");
        Thread consumer2 = new Thread(() -> {
            try {
                for (int i = 0; i < 5; i++) {
                    demo.consume();
                    Thread.sleep(900);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "ken-consumer-2");
        producer.start();
        consumer1.start();
        consumer2.start();
    }
}

join()的底层是通过调用wait()实现的，让当前线程等待目标线程执行完毕。当目标线程执行完毕后，JVM会自动调用notifyAll()唤醒所有等待的线程。

public final synchronized void join(long millis) throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;
    if (millis < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }
    if (millis == 0) {
        while (isAlive()) {
            wait(0);
        }
    } else {
        while (isAlive()) {
            long delay = millis - now;
            if (delay <= 0) {
                break;
            }
            wait(delay);
            now = System.currentTimeMillis() - base;
        }
    }
}

主要用于等待一个或多个线程执行完毕后再继续执行当前线程，如并行任务的结果汇总。

package com.jam.demo;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class JoinDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread task1 = new Thread(() -> {
            try {
                log.info("任务1开始执行");
                Thread.sleep(2000);
                log.info("任务1执行完毕");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "ken-task-1");
        Thread task2 = new Thread(() -> {
            try {
                log.info("任务2开始执行");
                Thread.sleep(3000);
                log.info("任务2执行完毕");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "ken-task-2");
        task1.start();
        task2.start();
        log.info("主线程等待任务1和任务2执行完毕");
        task1.join();
        task2.join();
        log.info("所有任务执行完毕，主线程继续执行");
    }
}

在大多数场景下，建议使用notifyAll()，避免信号丢失问题。

理解Java线程的生命周期与状态转换，以及interrupt()、wait()、notify()、join()等核心方法的底层原理，是编写高质量并发程序的关键。

深入拆解Java线程：生命周期流转与核心方法底层原理

Java线程是并发编程核心，其生命周期含NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED六种状态，配合interrupt()、wait()/notify()、join()等方法实现协作与控制，掌握状态转换与原理是编写高效稳定并发程序的基础。

云计算

深入解析Java线程生命周期与核心并发方法，包括NEW、RUNNABLE、BLOCKED等6种状态转换机制，详解interrupt()、wait()、notify()、join()等方法的底层实现原理及正确使用场景，帮助开发者掌握高效并发编程技巧。

Java

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

深入拆解Java线程：生命周期流转与核心方法底层原理

深入拆解Java线程：生命周期流转与核心方法底层原理

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐