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

最新推荐文章于 2024-09-16 12:00:00 发布

幻荼

最新推荐文章于 2024-09-16 12:00:00 发布

阅读量1.5k

点赞数

分类专栏： java学习文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_62718027/article/details/131332782

版权

java学习专栏收录该内容

14 篇文章 0 订阅

订阅专栏

五.计时等待状态（Timed 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());
    }
}