线程的状态

最新推荐文章于 2025-11-27 10:55:11 发布

最新推荐文章于 2025-11-27 10:55:11 发布 · 258 阅读

文章标签：

#java

多线程专栏收录该内容

18 篇文章

订阅专栏

本文详细介绍了Java线程的五种基本状态（NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED），以及它们之间的转换过程，以示例演示了线程状态在不同操作下的变化，特别关注了锁和等待通知的作用。

线程的状态有哪些

线程的状态是一个枚举类型 Thread.State，可以通过Thread.State.values()获取线程的状态集合

public static void main(String[] args) {
        //通过foreach遍历state的集合
        for(Thread.State state : Thread.State.values()){
            System.out.println(state);
        }
    }

这些线程的状态的含义是什么？

NEW: 安排了⼯作, 还未开始⾏动

RUNNABLE: 可⼯作的. ⼜可以分成正在⼯作中和即将开始⼯作.

BLOCKED:因为锁竞争而进入的排队等待状态.

WAITING:一个线程在等待另一个线程执行一个(唤醒)动作时，该线程进入Waiting状态.

TIMED_WAITING:同WAITING但是指定一个时间参数，超时将结束该状态.

TERMINATED: ⼯作完成了.

线程的状态之间的转换

1)观察 NEW RUNNABLE TERMINATED之间的转换

public static void main(String[] args) {
        //创建一个只执行将n递增到50的线程
        Thread t = new Thread(() -> {
            int n = 0;
            while(n <= 50){
                n++;
            }
        },"线程t");
        //打印线程的名字和状态
        System.out.println(t.getName()+" "+t.getState());
        // 开启线程
        t.start();
        //如果t线程仍然在工作 则打印名字和状态
        while(t.isAlive()){
            System.out.println(t.getName()+" "+t.getState());
        }
        //此时t线程工作结束
        System.out.println(t.getName()+" "+t.getState());
    }

从运行结果来看第一次打印的 NEW 为线程开始工作前所打印，此时没有调用start方法去内核中创建线程，之后打印的 RUNNABLE 为线程在执行时 while循环打印的内容，打印条件为线程t在工作中，最后打印的 TERMINATED 为while循环结束后打印此时t线程工作完毕但是Thread对象t仍然存在，内核中不存在线程t

2) 观察 WAITING BLOCKED TIMED_WAITING之间的转换

public static void main(String[] args) {
        //创建一个锁对象
        Object lock = new Object();
        Thread t1 = new Thread(() -> {
            //使用锁对象上锁
            synchronized (lock){
                while(true){
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"t1");
        Thread t2 = new Thread(() -> {
            synchronized (lock){
                while(true){
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"t2");
        t1.start();
        t2.start();
    }

使用jconsole 可以观察到

t1由于sleep且有参数限制所以处于 TIMED_WAITING状态

t2由于锁对象被t1上锁所以t2处于BLOCKED状态

如果将上述t1中的sleep改为 wait

//创建一个锁对象
        Object lock = new Object();
        Thread t1 = new Thread(() -> {
            //使用锁对象上锁
            synchronized (lock){
                while(true){
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"t1");
.......