线程的几种状态（看了肯定会o）

是喆喆不是哲哲

已于 2023-11-02 17:28:15 修改

阅读量74

点赞数

文章标签： java-ee jvm

于 2023-11-02 17:25:48 首次发布

本文链接：https://blog.csdn.net/weixin_64816913/article/details/134186656

版权

文章目录

- 线程的共几种状态
- 状态演示（包含代码）
- 状态之间的切换条件
- 总结

线程的共几种状态

不懂线程啥概念的，看看博主上一篇博客

没错线程共有6种状态，让我们一起来看看共哪6种吧！

1.NEW: 安排了工作, 还未开始行动
2.RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作.
3.BLOCKED: 这几个都表示排队等着其他事情
4.WAITING: 这几个都表示排队等着其他事情
5.TIMED_WAITING: 这几个都表示排队等着其他事情
6.TERMINATED: 工作完成了

系统的说这6种

（1）新建状态（NEW）: 当我们创建一个新的Thread对象时，该线程就处于新建状态，例如：Thread t = new Thread();

（2）可运行状态（RUNNABLE）: 当线程对象调用start()方法后，线程进入可运行状态。在这个状态下，线程已经做好了准备，随时等待CPU调度执行，这个状态包括了"就绪"和"运行"状态。

（3）阻塞状态（BLOCKED）: 线程在等待获取一个锁以进入或重新进入同步代码块时，它会进入阻塞状态。只有当该锁被释放并且线程被调度去获取这个锁，线程才能转换到RUNNABLE状态。

（4）等待状态（WAITING）: 线程进入等待状态，是因为它调用了其它线程的join方法，或者调用了无参数的wait方法。在这种情况下，线程会等待另一个线程的操作完成或者等待notify/notifyAll消息。

（5）定时等待状态（TIMED_WAITING）: 线程进入定时等待状态，是因为它调用了sleep或者带有指定时间的wait或join方法。在指定的时间过去之后，线程会自动返回RUNNABLE状态。如果它是由于调用wait或join方法进入的定时等待状态，还需要等待notify/notifyAll消息或者等待join的线程终止。

（6）终止状态（TERMINATED）: 线程任务执行完毕或者由于异常而结束，线程就会进入终止状态。在这个状态下，线程的生命周期实际上已经结束了，它不能再转换到其他任何状态。

状态演示（包含代码）

（1）新建状态（NEW）:

public class test2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
           for(int i = 0;i<1000000;i++){
 
           }
        });
        //t调用start之前,是NEW状态.
        System.out.println("线程执行之前:"+t.getState());
        t.start();
        t.join();
        //线程执行完毕之后,就是TERMINATED状态.
        System.out.println("线程执行之后:"+t.getState());
    }
}

结果：

（2）可运行状态（RUNNABLE）:

public class test2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
           for(int i = 0;i<1000;i++){
 
           }
        });
        System.out.println("线程执行之前:"+t.getState());
        t.start();
        //线程处于可执行状态
        System.out.println("线程运行中:"+t.getState());
        t.join();
        System.out.println("线程运行完:"+t.getState());
    }
}

结果：

（3）阻塞状态（BLOCKED）：

public class test2 {
    public static void main(String[] args) throws InterruptedException {
        Object obj1 = new Object();
        Object obj2 = new Object();
        Thread t1 = new Thread(()->{
            synchronized (obj1){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (obj2){
 
                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (obj2){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (obj1){
 
                }
            }
        });
 
        t1.start();
        Thread.sleep(100);
        t2.start();
        Thread.sleep(1500);
        System.out.println(t2.getState());
        t1.join();
        t2.join();
 
    }
}

结果：

（4）等待状态（WAITING）:

public class test2 {
    public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();
        Thread t1 = new Thread(()->{
            for(int i = 0;i<1000;i++){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            synchronized (obj){
                obj.notify();
            }
            System.out.println("线程t1执行完毕!");
        });
        Thread t2 = new Thread(()->{
            synchronized (obj){
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        //此时t2没有调用start方法,是NEW
        System.out.println("t2 start之前:"+t2.getState());
        t2.start();
        Thread.sleep(10);
        //此时线程t2等待线程t1执行完毕,应该是WAITING状态
        System.out.println("t2 wait中:"+t2.getState());
        t1.join();
        t2.join();
        //此时t2执行完毕,TERMINATED
        System.out.println("t2执行完成:"+t2.getState());
    }
}

结果：