异常教程

Java 实例 – 获取线程状态（长文解析）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

在 Java 编程中，多线程技术是提升程序性能和实现复杂功能的重要工具。然而，线程的生命周期管理、状态转换以及状态监控，往往是开发者容易忽视或理解困难的环节。本文将以“Java 实例 – 获取线程状态”为核心，通过循序渐进的讲解，帮助读者掌握线程状态的获取方法、应用场景及核心原理。无论是编程初学者还是中级开发者，都能通过本文的实例分析与代码示例，深入理解线程状态管理的实战技巧。

一、线程状态的定义与分类

1.1 线程状态的概念

线程状态是指线程在生命周期中所处的特定阶段。Java 提供了 Thread.State 枚举类型，将线程状态划分为 6 种类型：

  • NEW：线程对象被创建但尚未启动。
  • RUNNABLE：线程正在运行或处于可运行状态（等待 CPU 时间片）。
  • BLOCKED：线程因争夺同步锁而被阻塞。
  • WAITING：线程无限期等待其他线程的唤醒。
  • TIMED_WAITING：线程在指定时间内等待其他线程的唤醒。
  • TERMINATED：线程已执行完毕或因异常终止。

1.2 线程状态的比喻理解

可以将线程状态想象为交通灯的信号灯状态：

  • NEW：车辆还未进入车道（等待出发）。
  • RUNNABLE：车辆正在行驶（占用道路资源）。
  • BLOCKED：车辆因红灯或拥堵被阻塞。
  • WAITING/TIMED_WAITING：车辆在停车场等待召唤。
  • TERMINATED：车辆抵达终点并熄火。

二、如何获取线程状态

2.1 核心方法：Thread.getState()

Java 提供了 Thread.getState() 方法，可直接获取线程的当前状态。以下是基础使用示例：

public class ThreadStateExample {  
    public static void main(String[] args) {  
        Thread thread = new Thread(() -> {  
            System.out.println("Thread is running...");  
        });  
        System.out.println("Before start: " + thread.getState()); // 输出：NEW  
        thread.start();  
        System.out.println("After start: " + thread.getState()); // 可能输出：RUNNABLE 或 NEW（因线程启动的异步性）  
    }  
}

2.2 状态获取的注意事项

由于线程状态是动态变化的，直接调用 getState() 可能无法捕获精确的瞬时状态。因此，在实际开发中，建议通过 循环监控 或 结合日志输出 的方式，更稳定地观察状态变化。

三、线程状态的典型应用场景

3.1 监控线程阻塞（BLOCKED）

当多个线程竞争同一对象的锁时，线程可能进入 BLOCKED 状态。以下代码演示了如何通过 getState() 检测线程阻塞：

public class BlockedStateExample {  
    private static final Object lock = new Object();  

    public static void main(String[] args) {  
        Thread thread1 = new Thread(() -> {  
            synchronized (lock) {  
                try {  
                    Thread.sleep(2000); // 持有锁 2 秒  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        });  

        Thread thread2 = new Thread(() -> {  
            synchronized (lock) {  
                System.out.println("Thread2 state: " + Thread.currentThread().getState()); // 输出：BLOCKED（因锁被 thread1 占用）  
            }  
        });  

        thread1.start();  
        thread2.start();  
    }  
}

3.2 等待与唤醒（WAITING/TIMED_WAITING）

通过 Object.wait()、Thread.sleep() 等方法，线程会进入 WAITING 或 TIMED_WAITING 状态。例如：

public class WaitingStateExample {  
    public static void main(String[] args) {  
        Thread thread = new Thread(() -> {  
            try {  
                Thread.sleep(3000); // 进入 TIMED_WAITING 状态  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            System.out.println("Thread is terminated."); // 进入 TERMINATED 状态  
        });  

        thread.start();  
        System.out.println("Thread state after sleep: " + thread.getState()); // 输出：TIMED_WAITING  
    }  
}

四、线程状态转换的完整案例

4.1 全生命周期跟踪

以下案例通过 线程启动、运行、阻塞、终止 的全流程，展示状态的变化：

public class FullLifecycleExample {  
    public static void main(String[] args) {  
        Thread monitorThread = new Thread(() -> {  
            Thread targetThread = Thread.getAllStackTraces().keySet().stream()  
                    .filter(t -> t.getName().equals("WorkerThread")).findFirst().orElse(null);  

            while (targetThread.getState() != Thread.State.TERMINATED) {  
                System.out.println("Current state: " + targetThread.getState());  
                try {  
                    Thread.sleep(500); // 每 0.5 秒检查一次状态  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
        });  

        Thread workerThread = new Thread(() -> {  
            System.out.println("Worker thread is starting...");  
            synchronized (this) {  
                try {  
                    wait(4000); // 进入 WAITING 状态  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  
            System.out.println("Worker thread is terminating...");  
        }, "WorkerThread");  

        workerThread.start();  
        monitorThread.start();  
    }  
}

4.2 输出结果分析

运行上述代码后，控制台可能输出以下序列：

Before start: NEW  
After start: RUNNABLE  
Current state: RUNNABLE  
Current state: WAITING  
Current state: TERMINATED

通过监控线程的 getState()，可以清晰地观察到从 RUNNABLE 到 WAITING，最终到 TERMINATED 的状态转换。

五、常见问题与解决方案

5.1 线程状态为何不稳定？

由于线程状态是瞬时变化的，直接调用 getState() 可能因时间差导致结果不准确。建议结合 循环检测 或 日志记录 来提升准确性。

5.2 如何避免线程阻塞（BLOCKED）？

减少同步代码块的粒度，使用 ReentrantLock 的超时机制，或采用无锁设计模式（如 ConcurrentHashMap），可降低线程阻塞的概率。

六、结论

通过本文的讲解与实例演示，读者应已掌握 Java 线程状态的核心概念、获取方法及实际应用场景。无论是调试多线程程序、优化线程资源分配，还是设计高并发系统，理解线程状态的动态变化均至关重要。建议读者通过实践代码示例，进一步巩固对“Java 实例 – 获取线程状态”这一主题的理解。

未来，随着 Java 版本的迭代与多线程技术的演进，开发者需持续关注线程状态管理的最佳实践，以应对更复杂的并发场景。

最新发布

查看更多文章