《JavaEE》Java 线程的几种状态-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_69996872/article/details/129763907

👑作者主页：Java冰激凌
📖专栏链接：JavaEE

线程在Java中是有状态的分别处于不同的时机

我们来浅浅的分析一下他这些状态出现的条件其中在Java中获取线程当前状态的方法是

(方法名）.getState();

NEW

new状态会出现在线程刚刚创建的时候此时还没有执行线程意思就是还未调用start方法

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

当我们尝试运行线程的时候此时我们会出现一个新的状态 RUNNABLE

RUNNABLE

RUNNABLE 状态：表示当前线程是就绪状态随时可以被调度到CPU上执行（如果一个线程没有执行sleep或者wait之类的其他阻塞操作那么此时大概率是正处于RUNNABLE状态的）

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

此时的线程正处于执行状态如果我们在任务中添加一条sleep 那么我们获取线程的状态可能会出现TIMED_WAITING

TIMED_WAITING

TIMED_WAITING：表示此时线程在处于休眠中（但是这个休眠是有时间的）

这个就类似于我准备14:00去上课此时是13:00 我定了一个一个小时候的闹钟

也就等于我sleep（1h）

public class ThreadDemo3 {
    public static void main (String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(true){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(1);
        //如果不加阻塞 那么我们的主线程执行速度是非常快的 
        //会出现线程还未走到休眠已经执行到输出状态了 大概率会输出为RUNNABLE
        System.out.println(t.getState());
    }
}

我们也可以尝试在RUNNABLE的代码基础上执行一个阻塞 wait 就可以看到我们一个新的状态 WAITING

WAITING

WAITING：状态出现在线程处于阻塞时期正在等待被唤醒notify

public class ThreadDemo4 {
    static Object block = new Object();
    public static void main (String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(true){
                synchronized(block){
                    try {
                        block.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        t.start();
        Thread.sleep(10);
        System.out.println(t.getState());
    }
}

注意！！！我们在使用wait的时候必须要搭配锁来使用意思是如果我们要使用wait方法要使用synchronized包裹起来（wait要搭配synchronized来使用）

我们正在处于加锁状态那么此时会出现BLOCKED状态

BlOCKED

BLOCK：当前线程正在等待锁导致了当前线程阻塞

public class ThreadDemo5 {
    static Object block = new Object();
    public static void main (String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            synchronized (block){
                while(true){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (block){
                System.out.println("hello Thread t2");
            }
        });
        t1.start();
        t2.start();
        System.out.println(t2.getState());
    }
}

我们可以看到当他t1线程一直持有锁的时候 t2线程是无法获取的一直处于等待锁的时机所以打印语句也一直不会执行此时他所处于的状态为BLOCKED

那么当我们任务结束会出现一个TERMINATED状态

TERMINATED

TERMINATED:这个状态出现于线程任务执行后当线程执行完毕后其中的任务会销毁但是线程的类不会立即销毁因为我们的线程只会执行一次执行完一次后如果再执行线程就会出现异常

public class ThreadDemo6 {
    public static void main (String[] args) {
        Thread t1 = new Thread(()->{

        });
        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(t1.getState());
    }
}