在程序运行过程中，线程的状态是什么？进来看看就通透了

🌈🌈🌈今天给大家分享的是:在程序运行过程中，怎么得到线程的状态。这部分内容对于我们更加深入的理解线程会有很大的帮助。下面我就来介绍一下线程的状态。

清风的CSDN博客

🛩️🛩️🛩️希望我的文章能对你有所帮助，有不足的地方还请各位看官多多指教，大家一起学习交流！🛩️🛩️🛩️

✈️✈️✈️动动你们发财的小手，点点关注点点赞！在此谢过啦！哈哈哈！✈️✈️✈️

一、观察线程的所有状态 

 话不多说，我们先来看看线程都有哪些状态：

线程的状态是一个枚举类型 Thread.State

public class Demo4 {
    public static void main(String[] args) {
        for (Thread.State state :Thread.State.values()) {
            System.out.println(state);
        }
    }
}

 那么通过上面这个简单的测试程序，根据运行结果，我们就可以看到在程序运行过程中，线程可能会出现的所有状态：

问题来了，这些状态的意义是什么呢？下面我们来看：

new	安排了工作 , 还未开始行动
runnable	可工作的 . 又可以分成正在工作中和即将开始工作
blocked	表示排队等着其他事情，因为锁产生阻塞
waiting	表示排队等着其他事情，调用wait产生阻塞
timed_waiting	表示排队等着其他事情，由sleep或join()产生阻塞
terminated	工作完成了

 1.1 观察NEW状态

public class Test_NEW_State {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            while (true){
                //System.out.println("hello thread!!");
            }
        });
        System.out.println("当前状态:>"+t.getState());//获取当前线程状态
         t.start();
    }
}

 在上面的代码中，在start(线程开始)之前获取状态，意味着当前状态只是被安排了工作，但是还未开始行动，因此就是NEW状态：

 1.2 观察TERMINATED状态

public class Test_TREMINATED_State {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("未安排工作时状态:>"+t.getState());
        t.start();

        t.join();//等待进程执行完成
        System.out.println("等待线程执行结束后:>"+t.getState());
    }
}

 在上面的代码中，创建线程后，先获取当前线程的状态，因为此时还没有start，所以未安排工作时的线程状态就是：NEW。而执行t.join()等待线程执行结束，我们得到的线程状态就是TREMINATED。

 1.3 观察RUNNABLE状态

public class Test_RUNNABLE_State {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (true){
                //什么都不干
            }
        });
        System.out.println("start之前:>"+t.getState());
        t.start();
        Thread.sleep(1000);
        System.out.println("线程开始(准备)执行后:>"+t.getState());
    }
}

 在上面的代码中，依然是在start之前获取线程的状态，毫无疑问肯定是NEW，在线程休眠1000ms后，再次获取线程状态，此时就是就绪(执行)状态了。

就绪状态，可以理解成两种情况:>

• 线程正在CPU上运行。
• 线程在这里排队，随时都可以去CPU上执行。

1.4 观察WAITING 、 BLOCKED 、 TIMED_WAITING 状态的转换 

public class Test_State {
    public static void main(String[] args) {
        final Object object = new Object();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object){
                    while (true){
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        },"t1");
        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object){
                    System.out.println("hello");
                }
            }
        },"t2");
        t2.start();


    }
}

 使用 jconsole 可以看到 t1 的状态是 TIMED_WAITING , t2 的状态是 BLOCKED。

 修改上面的代码, 把 t1 中的 sleep 换成 wait ：

public class Test_State1 {
    public static void main(String[] args) {
        final Object object = new Object();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object){
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"t1");
        t1.start();
    }
}

使用 jconsole 可以看到 t1 的状态是 WAITING  

结论 :

• BLOCKED 表示等待获取锁, WAITING 和 TIMED_WAITING 表示等待其他线程发来通知.
• TIMED_WAITING 线程在等待唤醒，但设置了时限; WAITING 线程在无限等待唤醒

 

---

🌈🌈🌈好啦，今天的分享就到这里！

🛩️🛩️🛩️希望各位看官读完文章后，能够有所提升。

🎉🎉🎉创作不易，还希望各位大佬支持一下！

✈️✈️✈️点赞，你的认可是我创作的动力！

⭐⭐⭐收藏，你的青睐是我努力的方向！

✏️✏️✏️评论：你的意见是我进步的财富！