文章目录
-
- 引言：为什么需要理解线程生命周期？
- 一、Java线程生命周期全景图
- 二、线程状态的官方定义
- 三、详细解析每种状态及转换
-
- [1. 新建状态（NEW）](#1. 新建状态（NEW）)
- [2. 就绪/运行状态（RUNNABLE）](#2. 就绪/运行状态（RUNNABLE）)
- [3. 阻塞状态（BLOCKED）](#3. 阻塞状态（BLOCKED）)
- [4. 等待状态（WAITING）](#4. 等待状态（WAITING）)
- [5. 超时等待状态（TIMED_WAITING）](#5. 超时等待状态（TIMED_WAITING）)
- [6. 终止状态（TERMINATED）](#6. 终止状态（TERMINATED）)
- 四、线程状态转换的完整代码示例
- 五、线程状态转换的底层原理
-
- [1. 状态转换的源码分析](#1. 状态转换的源码分析)
- [2. 操作系统层面的线程状态](#2. 操作系统层面的线程状态)
- 六、实战应用：线程池中的线程状态管理
- 七、常见问题与陷阱
-
- [1. 线程状态监控的常见问题](#1. 线程状态监控的常见问题)
- [2. 最佳实践建议](#2. 最佳实践建议)
- [八、高级话题：虚拟线程（Project Loom）](#八、高级话题：虚拟线程（Project Loom）)
- 九、性能监控与调试工具
-
- [1. 使用JConsole监控线程状态](#1. 使用JConsole监控线程状态)
- [2. 使用ThreadMXBean编程监控](#2. 使用ThreadMXBean编程监控)
- 总结
引言：为什么需要理解线程生命周期？
在当今多核处理器普及的时代，多线程编程已成为Java开发工程师必须掌握的技能。想象一下这样的场景：一个电商网站需要同时处理成千上万的用户请求，一个视频播放器需要在后台下载数据的同时保持界面流畅，一个数据分析系统需要并行处理海量数据...这些场景都离不开多线程。然而，要编写出正确、高效的多线程程序，深入理解线程的生命周期至关重要。今天，我们就来彻底解析Java线程生命周期的每一个细节！
一、Java线程生命周期全景图
首先，让我们通过一个流程图来总览Java线程的完整生命周期：
start
获得CPU时间片
时间片用完/yield
等待I/O/锁
sleep/wait/join
sleep/wait/join
带超时
获得锁
notify/notifyAll
超时/notify
run方法结束
新建状态 New
就绪状态 Runnable
运行状态 Running
阻塞状态 Blocked
等待状态 Waiting
限时等待 Timed Waiting
终止状态 Terminated
二、线程状态的官方定义
Java线程的状态在java.lang.Thread.State枚举中明确定义：
java
public enum State {
/**
* 新建状态：线程被创建但尚未启动
*/
NEW,
/**
* 可运行状态：线程正在Java虚拟机中执行，
* 但可能正在等待操作系统资源（如处理器）
*/
RUNNABLE,
/**
* 阻塞状态：线程正在等待监视器锁
* 进入synchronized块/方法时
*/
BLOCKED,
/**
* 等待状态：线程无限期等待另一个线程执行特定操作
*/
WAITING,
/**
* 超时等待状态：线程正在限时等待另一个线程执行操作
*/
TIMED_WAITING,
/**
* 终止状态：线程已经完成执行
*/
TERMINATED;
}三、详细解析每种状态及转换
1. 新建状态（NEW）
特点：
- 线程对象被创建，但尚未调用start()方法
- 此时线程尚未分配系统资源
java
public class ThreadLifecycleDemo {
public static void main(String[] args) {
// 创建线程对象 - 此时线程处于NEW状态
Thread thread = new Thread(() -> {
System.out.println("线程执行中...");
});
// 查看线程状态
System.out.println("创建后线程状态: " + thread.getState()); // 输出: NEW
System.out.println("线程是否存活: " + thread.isAlive()); // 输出: false
}
}2. 就绪/运行状态（RUNNABLE）
重要理解：RUNNABLE状态实际上包含了两个子状态：
- 就绪（Ready）：等待CPU时间片
- 运行（Running）：正在CPU上执行
java
public class RunnableStateDemo {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
// 模拟线程执行
for (int i = 0; i < 5; i++) {
System.out.println("线程执行第" + (i + 1) + "次");
try {
// 短暂睡眠，让出CPU
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
// 主线程等待一段时间后查看状态
Thread.sleep(50);
System.out.println("线程启动后状态: " + thread.getState()); // 可能输出: RUNNABLE
// 等待线程执行完毕
thread.join();
}
}3. 阻塞状态（BLOCKED）
触发条件：
- 线程试图获取一个被其他线程持有的对象锁
- 等待进入synchronized同步块或方法
java
public class BlockedStateDemo {
private static final Object lock = new Object();
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(() -> {
synchronized (lock) {
System.out.println("线程1获得锁，开始执行");
try {
Thread.sleep(2000); // 持有锁2秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程1释放锁");
}
});
Thread thread2 = new Thread(() -> {
System.out.println("线程2尝试获取锁...");
synchronized (lock) {
System.out.println("线程2获得锁，开始执行");
}
});
thread1.start();
Thread.sleep(100); // 确保thread1先获得锁
thread2.start();
Thread.sleep(100); // 给thread2时间尝试获取锁
// 此时thread2应该处于BLOCKED状态
System.out.println("线程2状态: " + thread2.getState()); // 输出: BLOCKED
thread1.join();
thread2.join();
}
}4. 等待状态（WAITING）
触发条件：
- 调用Object.wait()方法（不带超时）
- 调用Thread.join()方法（不带超时）
- 调用LockSupport.park()方法
java
public class WaitingStateDemo {
private static final Object lock = new Object();
public static void main(String[] args) throws InterruptedException {
Thread waitingThread = new Thread(() -> {
synchronized (lock) {
System.out.println("线程进入等待状态...");
try {
lock.wait(); // 无限期等待
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程被唤醒，继续执行");
}
});
waitingThread.start();
// 确保线程进入waiting状态
Thread.sleep(100);
System.out.println("线程状态: " + waitingThread.getState()); // 输出: WAITING
// 唤醒线程
Thread.sleep(1000);
synchronized (lock) {
lock.notify();
}
waitingThread.join();
}
}
// Thread.join()导致的WAITING状态示例
class JoinWaitingDemo {
public static void main(String[] args) throws InterruptedException {
Thread childThread = new Thread(() -> {
try {
Thread.sleep(3000); // 模拟长时间执行
System.out.println("子线程执行完毕");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
Thread mainThread = new Thread(() -> {
System.out.println("主线程等待子线程完成...");
try {
childThread.join(); // 无限期等待子线程结束
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("主线程继续执行");
});
childThread.start();
mainThread.start();
Thread.sleep(100);
System.out.println("主线程状态: " + mainThread.getState()); // 输出: WAITING
}
}5. 超时等待状态（TIMED_WAITING）
触发条件：
- Thread.sleep(long millis)
- Object.wait(long timeout)
- Thread.join(long millis)
- LockSupport.parkNanos()
- LockSupport.parkUntil()
java
public class TimedWaitingStateDemo {
public static void main(String[] args) throws InterruptedException {
// 示例1: sleep导致的TIMED_WAITING
Thread sleepThread = new Thread(() -> {
try {
System.out.println("线程即将睡眠2秒");
Thread.sleep(2000);
System.out.println("线程唤醒");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
sleepThread.start();
Thread.sleep(100);
System.out.println("sleep线程状态: " + sleepThread.getState()); // TIMED_WAITING
// 示例2: wait with timeout
Object monitor = new Object();
Thread waitThread = new Thread(() -> {
synchronized (monitor) {
try {
System.out.println("线程开始限时等待");
monitor.wait(3000); // 最多等待3秒
System.out.println("线程结束等待");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
waitThread.start();
Thread.sleep(100);
System.out.println("wait线程状态: " + waitThread.getState()); // TIMED_WAITING
// 示例3: join with timeout
Thread longThread = new Thread(() -> {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
Thread joinThread = new Thread(() -> {
try {
System.out.println("开始限时join其他线程");
longThread.join(2000); // 最多等待2秒
System.out.println("join结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
longThread.start();
joinThread.start();
Thread.sleep(100);
System.out.println("join线程状态: " + joinThread.getState()); // TIMED_WAITING
sleepThread.join();
waitThread.join();
joinThread.join();
longThread.join();
}
}6. 终止状态（TERMINATED）
触发条件：
- run()方法正常执行完毕
- 线程抛出未捕获的异常
- 调用stop()方法（已废弃，不推荐使用）
java
public class TerminatedStateDemo {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
System.out.println("线程开始执行");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程执行完毕");
});
System.out.println("启动前状态: " + thread.getState()); // NEW
System.out.println("启动前是否存活: " + thread.isAlive()); // false
thread.start();
Thread.sleep(500);
System.out.println("执行中状态: " + thread.getState()); // TIMED_WAITING
System.out.println("执行中是否存活: " + thread.isAlive()); // true
// 等待线程完全结束
thread.join();
System.out.println("结束后状态: " + thread.getState()); // TERMINATED
System.out.println("结束后是否存活: " + thread.isAlive()); // false
// 注意：终止状态的线程不能重新启动
try {
thread.start(); // 抛出IllegalThreadStateException
} catch (IllegalThreadStateException e) {
System.out.println("异常：不能重新启动已终止的线程");
}
}
}四、线程状态转换的完整代码示例
下面是一个综合示例，展示线程状态的各种转换：
java
public class CompleteThreadLifecycleDemo {
private static final Object sharedLock = new Object();
private static boolean condition = false;
public static void main(String[] args) throws Exception {
System.out.println("========== Java线程生命周期完整演示 ==========\n");
// 1. NEW -> RUNNABLE -> TERMINATED
System.out.println("1. 正常生命周期演示:");
Thread normalThread = new Thread(() -> {
System.out.println(" - 线程正常执行任务");
}, "NormalThread");
printState(normalThread);
normalThread.start();
Thread.sleep(10);
printState(normalThread);
normalThread.join();
printState(normalThread);
System.out.println();
// 2. NEW -> RUNNABLE -> BLOCKED -> RUNNABLE -> TERMINATED
System.out.println("2. 阻塞状态演示:");
Thread blocker = new Thread(() -> {
synchronized (sharedLock) {
System.out.println(" - Blocker获得锁，将持有2秒");
try { Thread.sleep(2000); } catch (InterruptedException e) {}
}
}, "Blocker");
Thread waiter = new Thread(() -> {
System.out.println(" - Waiter尝试获取锁...");
synchronized (sharedLock) {
System.out.println(" - Waiter获得锁");
}
}, "Waiter");
blocker.start();
Thread.sleep(10); // 确保blocker先获得锁
waiter.start();
Thread.sleep(10); // 确保waiter开始运行
printState(waiter); // 应该显示BLOCKED
blocker.join();
Thread.sleep(10);
printState(waiter); // 应该显示TERMINATED或RUNNABLE
waiter.join();
System.out.println();
// 3. NEW -> RUNNABLE -> WAITING -> RUNNABLE -> TERMINATED
System.out.println("3. 等待状态演示:");
final Object waitLock = new Object();
Thread waitingThread = new Thread(() -> {
synchronized (waitLock) {
System.out.println(" - WaitingThread进入等待");
try { waitLock.wait(); } catch (InterruptedException e) {}
System.out.println(" - WaitingThread被唤醒");
}
}, "WaitingThread");
Thread notifierThread = new Thread(() -> {
try { Thread.sleep(1000); } catch (InterruptedException e) {}
synchronized (waitLock) {
System.out.println(" - NotifierThread发送通知");
waitLock.notify();
}
}, "NotifierThread");
waitingThread.start();
notifierThread.start();
Thread.sleep(100);
printState(waitingThread); // 应该显示WAITING
waitingThread.join();
notifierThread.join();
System.out.println();
// 4. NEW -> RUNNABLE -> TIMED_WAITING -> RUNNABLE -> TERMINATED
System.out.println("4. 超时等待状态演示:");
Thread timedThread = new Thread(() -> {
System.out.println(" - TimedThread开始睡眠");
try { Thread.sleep(1500); } catch (InterruptedException e) {}
System.out.println(" - TimedThread唤醒");
}, "TimedThread");
timedThread.start();
Thread.sleep(100);
printState(timedThread); // 应该显示TIMED_WAITING
timedThread.join();
System.out.println("\n========== 演示结束 ==========");
}
private static void printState(Thread thread) {
System.out.printf(" 线程[%s] 状态: %-15s 是否存活: %s%n",
thread.getName(),
thread.getState(),
thread.isAlive());
}
}五、线程状态转换的底层原理
1. 状态转换的源码分析
让我们深入Thread类的源码，理解状态转换的实现：
java
// Thread类中关键的状态管理方法
public class Thread implements Runnable {
// 线程状态变量，volatile保证可见性
private volatile int threadStatus = 0;
// 获取线程状态
public State getState() {
return sun.misc.VM.toThreadState(threadStatus);
}
// 启动线程 - 状态从NEW变为RUNNABLE
public synchronized void start() {
if (threadStatus != 0) // 0代表NEW状态
throw new IllegalThreadStateException();
// 将线程添加到线程组
group.add(this);
boolean started = false;
try {
// 调用native方法启动线程
start0();
started = true;
} finally {
// 如果启动失败，从线程组中移除
if (!started) {
group.threadStartFailed(this);
}
}
}
private native void start0();
// sleep方法 - 使线程进入TIMED_WAITING状态
public static native void sleep(long millis) throws InterruptedException;
// yield方法 - 提示调度器让出CPU
public static native void yield();
// join方法实现
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); // 进入WAITING状态
}
} else {
while (isAlive()) {
long delay = millis - now;
if (delay <= 0) {
break;
}
wait(delay); // 进入TIMED_WAITING状态
now = System.currentTimeMillis() - base;
}
}
}
}2. 操作系统层面的线程状态
Java线程状态实际上是JVM对操作系统线程状态的抽象：
Java线程状态 Linux线程状态 Windows线程状态
----------- ------------- ---------------
NEW 创建中 CREATE_SUSPENDED
RUNNABLE READY/RUNNING READY/RUNNING
BLOCKED SLEEPING WAIT
WAITING SLEEPING WAIT
TIMED_WAITING SLEEPING WAIT
TERMINATED ZOMBIE TERMINATED六、实战应用：线程池中的线程状态管理
线程池是Java并发编程的核心组件，理解线程池中的线程状态尤为重要：
java
public class ThreadPoolStateDemo {
public static void main(String[] args) throws Exception {
// 创建固定大小的线程池
ExecutorService executor = Executors.newFixedThreadPool(3);
System.out.println("线程池中的线程状态演示：\n");
// 提交10个任务
List<Future<?>> futures = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
final int taskId = i;
Future<?> future = executor.submit(() -> {
System.out.printf("任务%d开始执行 - 线程: %s%n",
taskId, Thread.currentThread().getName());
// 模拟任务执行时间
try {
Thread.sleep(1000 + taskId * 100);
} catch (InterruptedException e) {
System.out.printf("任务%d被中断%n", taskId);
Thread.currentThread().interrupt();
}
System.out.printf("任务%d执行完成 - 线程: %s%n",
taskId, Thread.currentThread().getName());
});
futures.add(future);
}
// 等待所有任务提交后，查看线程状态
Thread.sleep(500);
System.out.println("\n任务提交后线程状态分析：");
// 获取线程池的工作线程
ThreadPoolExecutor poolExecutor = (ThreadPoolExecutor) executor;
System.out.printf("线程池大小: %d%n", poolExecutor.getPoolSize());
System.out.printf("活跃线程数: %d%n", poolExecutor.getActiveCount());
System.out.printf("等待队列大小: %d%n", poolExecutor.getQueue().size());
// 模拟获取线程状态（实际中需要通过扩展线程池来实现）
monitorThreadStates(poolExecutor);
// 等待所有任务完成
for (Future<?> future : futures) {
future.get();
}
// 关闭线程池
executor.shutdown();
boolean terminated = executor.awaitTermination(5, TimeUnit.SECONDS);
System.out.println("\n线程池是否已关闭: " + terminated);
System.out.println("\n最终状态：");
System.out.printf("已完成任务数: %d%n", poolExecutor.getCompletedTaskCount());
}
// 监控线程状态的辅助方法
private static void monitorThreadStates(ThreadPoolExecutor executor) {
// 实际项目中可以使用ThreadMXBean来监控线程状态
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
System.out.println("\n系统线程状态概览：");
for (ThreadInfo info : threadInfos) {
if (info.getThreadName().contains("pool")) {
System.out.printf("线程: %-25s 状态: %s%n",
info.getThreadName(),
info.getThreadState());
}
}
}
}
// 自定义线程池以更好地监控线程状态
class StateTrackingThreadPool extends ThreadPoolExecutor {
private final Map<Long, Thread.State> threadStates = new ConcurrentHashMap<>();
public StateTrackingThreadPool(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
@Override
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
threadStates.put(t.getId(), t.getState());
System.out.printf("线程[%s]执行前状态: %s%n", t.getName(), t.getState());
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
Thread current = Thread.currentThread();
threadStates.put(current.getId(), current.getState());
System.out.printf("线程[%s]执行后状态: %s%n",
current.getName(), current.getState());
}
public Map<Long, Thread.State> getThreadStates() {
return new HashMap<>(threadStates);
}
}七、常见问题与陷阱
1. 线程状态监控的常见问题
java
public class ThreadStateCommonIssues {
// 问题1：线程状态检查的竞态条件
public static void issue1() throws InterruptedException {
System.out.println("\n=== 问题1：状态检查的竞态条件 ===");
Thread thread = new Thread(() -> {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
thread.start();
// 错误做法：状态可能在检查后立即改变
if (thread.getState() == Thread.State.RUNNABLE) {
// 这里线程可能已经进入其他状态了
System.out.println("线程正在运行...");
}
// 正确做法：使用适当的同步机制
thread.join();
}
// 问题2：误判TIMED_WAITING状态
public static void issue2() throws InterruptedException {
System.out.println("\n=== 问题2：TIMED_WAITING的误判 ===");
Object lock = new Object();
Thread thread = new Thread(() -> {
synchronized (lock) {
try {
// 这里实际上是WAITING状态，不是TIMED_WAITING
lock.wait(); // 没有超时参数
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread.start();
Thread.sleep(50);
System.out.println("线程状态: " + thread.getState()); // WAITING
synchronized (lock) {
lock.notify();
}
thread.join();
}
// 问题3：线程中断的状态影响
public static void issue3() {
System.out.println("\n=== 问题3：中断对状态的影响 ===");
Thread thread = new Thread(() -> {
try {
System.out.println("线程开始睡眠");
Thread.sleep(5000);
} catch (InterruptedException e) {
System.out.println("线程被中断，当前状态: " +
Thread.currentThread().getState()); // RUNNABLE
// 恢复中断状态
Thread.currentThread().interrupt();
}
});
thread.start();
try {
Thread.sleep(100);
thread.interrupt(); // 中断睡眠中的线程
Thread.sleep(100);
System.out.println("中断后线程状态: " + thread.getState());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws InterruptedException {
issue1();
issue2();
issue3();
}
}2. 最佳实践建议
java
public class ThreadStateBestPractices {
// 最佳实践1：使用合适的同步机制代替忙等待
public static void practice1() {
System.out.println("最佳实践1：避免忙等待");
// 反模式：忙等待（Busy Waiting）
class BusyWaitExample {
private boolean flag = false;
public void badPractice() {
Thread worker = new Thread(() -> {
try {
Thread.sleep(1000);
flag = true;
} catch (InterruptedException e) {
e.printStackTrace();
}
});
worker.start();
// 忙等待 - 浪费CPU资源
while (!flag) {
// 空循环，CPU使用率100%
}
System.out.println("任务完成");
}
}
// 正确做法：使用wait/notify或高级并发工具
class GoodPractice {
private final Object lock = new Object();
private boolean flag = false;
public void goodPractice() throws InterruptedException {
Thread worker = new Thread(() -> {
try {
Thread.sleep(1000);
synchronized (lock) {
flag = true;
lock.notifyAll();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
});
worker.start();
synchronized (lock) {
while (!flag) {
lock.wait(); // 释放锁，进入WAITING状态
}
}
System.out.println("任务完成 - 高效等待");
}
}
}
// 最佳实践2：正确处理线程中断
public static void practice2() {
System.out.println("\n最佳实践2：正确处理中断");
Thread thread = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {
try {
// 执行任务
System.out.println("执行任务中...");
Thread.sleep(1000);
} catch (InterruptedException e) {
// 捕获InterruptedException后，中断状态被清除
System.out.println("线程被中断，准备退出");
// 重新设置中断状态
Thread.currentThread().interrupt();
break;
}
}
System.out.println("线程优雅退出");
});
thread.start();
try {
Thread.sleep(2500);
thread.interrupt();
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 最佳实践3：使用线程池管理线程生命周期
public static void practice3() {
System.out.println("\n最佳实践3：使用线程池");
ExecutorService executor = Executors.newFixedThreadPool(2);
for (int i = 0; i < 5; i++) {
final int taskId = i;
executor.execute(() -> {
System.out.printf("任务%d在线程%s中执行%n",
taskId, Thread.currentThread().getName());
try {
Thread.sleep(500);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
}
executor.shutdown();
try {
if (!executor.awaitTermination(3, TimeUnit.SECONDS)) {
executor.shutdownNow();
}
} catch (InterruptedException e) {
executor.shutdownNow();
}
System.out.println("所有任务完成，线程池已关闭");
}
public static void main(String[] args) throws InterruptedException {
practice1();
practice2();
practice3();
}
}八、高级话题：虚拟线程（Project Loom）
Java 19引入了虚拟线程（Virtual Threads），这是对传统平台线程的革命性改进：
java
// 虚拟线程示例（需要Java 19+）
public class VirtualThreadDemo {
public static void main(String[] args) {
System.out.println("=== 虚拟线程演示 ===");
// 创建虚拟线程
Thread virtualThread = Thread.ofVirtual()
.name("virtual-thread-1")
.start(() -> {
System.out.println("虚拟线程执行中: " +
Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
// 虚拟线程的状态与传统线程相同
System.out.println("虚拟线程状态: " + virtualThread.getState());
try {
virtualThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 使用虚拟线程执行器
System.out.println("\n使用虚拟线程执行器:");
try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 10; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.printf("任务%d在%s中执行%n",
taskId, Thread.currentThread());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
return taskId;
});
}
} // 自动关闭
System.out.println("所有虚拟线程任务完成");
}
}九、性能监控与调试工具
1. 使用JConsole监控线程状态
java
public class MonitoringDemo {
public static void main(String[] args) throws Exception {
System.out.println("启动线程状态监控演示...");
System.out.println("请使用JConsole连接此进程查看线程状态");
// 创建多个处于不同状态的线程
Object lock = new Object();
// RUNNABLE线程
new Thread(() -> {
while (true) {
try {
Thread.sleep(1000);
System.out.print(".");
} catch (InterruptedException e) {
break;
}
}
}, "Running-Thread").start();
// BLOCKED线程
new Thread(() -> {
synchronized (lock) {
try {
Thread.sleep(30000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Blocking-Thread").start();
// 多个等待锁的线程
for (int i = 0; i < 3; i++) {
new Thread(() -> {
synchronized (lock) {
// 获取锁后立即释放
}
}, "Blocked-Thread-" + i).start();
}
// WAITING线程
new Thread(() -> {
synchronized (lock) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "Waiting-Thread").start();
// TIMED_WAITING线程
for (int i = 0; i < 2; i++) {
new Thread(() -> {
try {
Thread.sleep(60000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "Timed-Waiting-" + i).start();
}
// 保持程序运行
Thread.sleep(120000);
System.out.println("\n演示结束");
}
}2. 使用ThreadMXBean编程监控
java
public class ThreadMXBeanDemo {
public static void main(String[] args) throws Exception {
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
// 启用CPU时间测量
threadMXBean.setThreadCpuTimeEnabled(true);
// 创建测试线程
ExecutorService executor = Executors.newFixedThreadPool(3);
for (int i = 0; i < 5; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.printf("任务%d开始%n", taskId);
try {
Thread.sleep(1000 + taskId * 200);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.printf("任务%d结束%n", taskId);
});
}
// 监控线程状态
Thread.sleep(500);
long[] threadIds = threadMXBean.getAllThreadIds();
System.out.println("\n=== 线程监控报告 ===");
System.out.printf("总线程数: %d%n", threadIds.length);
for (long threadId : threadIds) {
ThreadInfo threadInfo = threadMXBean.getThreadInfo(threadId);
if (threadInfo != null) {
System.out.printf("线程ID: %-5d 名称: %-25s 状态: %-15s CPU时间: %.2fms%n",
threadId,
threadInfo.getThreadName(),
threadInfo.getThreadState(),
threadMXBean.getThreadCpuTime(threadId) / 1_000_000.0);
}
}
// 检测死锁
long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
if (deadlockedThreads != null && deadlockedThreads.length > 0) {
System.out.println("\n检测到死锁！");
for (long threadId : deadlockedThreads) {
ThreadInfo threadInfo = threadMXBean.getThreadInfo(threadId);
System.out.println("死锁线程: " + threadInfo.getThreadName());
}
}
executor.shutdown();
executor.awaitTermination(5, TimeUnit.SECONDS);
}
}总结
Java线程生命周期是一个精心设计的模型，它抽象了操作系统线程的复杂行为，为开发者提供了清晰的编程接口。理解线程的六种状态及其转换关系，对于编写正确、高效、可靠的多线程程序至关重要。
