Java线程的六种状态(付代码解释)

目录

一.新建状态 (New)

解释

代码

运行结果

​编辑

二.运行状态(Runnable) 

 解释

代码

运行结果

 三.等待状态（Waiting）

解释

代码

运行结果

 四.阻塞状态（Blocked）

解释

代码

运行结果

 五.计时等待状态（Timed Waiting）

解释

代码

运行结果

 六.终止状态（Terminated）

解释

代码

运行结果

状态之间的切换条件

新建状态（New）：

运行状态（Runnable）：

阻塞状态（Blocked）：

等待状态（Waiting）：

计时等待状态（Timed Waiting）：

终止状态（Terminated）：

---

Java线程一共有六种状态,分别是

新建状态（New）

运行状态（Runnable）

阻塞状态（Blocked）

等待状态（Waiting）

计时等待状态（Timed Waiting）

终止状态（Terminated）

一.新建状态 (New)

解释

线程仅仅是被创建,但未被调用的状态

代码

getState查看线程状态

public class demo14 {
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            
        });
        System.out.println(t1.getState());
    }
}

运行结果

二.运行状态(Runnable) 

 解释

[正在运行中的]  或者  [已经能够运行]  的线程

代码

只是加了一个start调用

public class demo14 {
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            
        });
        t1.start();
        System.out.println(t1.getState());
    }
}

运行结果

 三.等待状态（Waiting）

解释

正在运行中的线程被中断后,处于被通知状态的等待状态,一旦接收到通知就继续运行

代码

调用wait方法让线程处于等待状态

public class demo14 {
     public static void main(String[] args) throws InterruptedException {
         Object ob = new Object();
         Thread t1 = new Thread(()->{
             synchronized (ob){
                 try {
                     ob.wait();
                 } catch (InterruptedException e) {
                     throw new RuntimeException(e);
                 }
             }
        });
         t1.start();
         Thread.sleep(1000);//这里sleep是为了避免主函数运行过快,显示Runnable
         System.out.println(t1.getState());
    }
}

运行结果

 四.阻塞状态（Blocked）

解释

多个线程竞争同一个锁,竞争失败的线程会处于该状态

代码

此时t2和t1同时竞争名为func的枷锁方法

因为t2先获得,所以t1只能处于阻塞等待

public class demo14 {
    synchronized public static void func() {
        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
     public static void main(String[] args) throws InterruptedException {
         Thread t1 = new Thread(()->{
             func();
         });

         Thread t2 = new Thread(()->{
             func();
         });
//t2先获得锁,t1只能阻塞等待
         t2.start();
         t1.start();
         System.out.println(t2.getState());
         System.out.println(t1.getState());
    }
}

运行结果

 五.计时等待状态（Timed Waiting）

解释

和等待相似,但是区别在于限定了一个时间,如果超过时间则取消等待,继续执行

代码

public class demo14 {
    public static void main(String[] args) throws InterruptedException {
        Object ob = new Object();
        Thread t1 = new Thread(()->{
            synchronized (ob){
                try {
                    ob.wait(10000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        Thread.sleep(1000);//这里sleep是为了避免主函数运行过快,显示Runnable
        System.out.println(t1.getState());
    }
}

运行结果

 六.终止状态（Terminated）

解释

线程运行结束,释放所有资源

代码

public class demo14 {
    public static void main(String[] args) throws InterruptedException {
        Object ob = new Object();
        Thread t1 = new Thread(()->{
        });
        t1.start();
        Thread.sleep(1000);//这里sleep是为了让线程运行完毕,避免主函数运行过快显示Runnable
        System.out.println(t1.getState());
    }
}

运行结果

 

状态之间的切换条件

新建状态（New）：

被创建就自动进入该状态

运行状态（Runnable）：

被调用(如start)后进入该状态

阻塞状态（Blocked）：

竞争锁失败后进入该状态

等待状态（Waiting）：

运行被中断(如wait),处于等待唤醒状态时进入该状态

计时等待状态（Timed Waiting）：

如果被带有时间的wait等方式中断,进入等待唤醒状态时进入该状态

终止状态（Terminated）：

全部执行完毕后,没有出错释放资源,进入该状态