Java EE——线程状态

用户11873138

发布于 2026-01-13 21:28:27

990

前言

从编写Java代码的角度来说，线程一共有六种状态；但是以操作系统的视角来看，线程状态可以分为物种

六种划分

调用getState()方法获取当前线程状态

一.NEW

定义：线程(对象)被创建但还没有启动

public class NEW {
    public static void main(String[] args) {
        Thread thread = new Thread(()->{});
        //thread创建完毕
        //NEW
        System.out.println(thread.getState());
    }
}

二.RUNNABLE

定义：线程创建并启动完毕，拥有执行代码的能力或者正在执行代码

public class RUNNABLE {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            while (true){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("Hello Thread");
            }
        });
        //调用start
        thread.start();
        //RUNNABLE
        System.out.println(thread.getState());
    }
}

三.WAITING

定义：线程处于等待状态，等待其他线程执行完毕(join)或者其他线程来唤醒(notify)

public class WAITING {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread thread = new Thread(()->{
            synchronized (locker){
                try {
                    //无时间参数的wait
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        thread.start();
        Thread.sleep(100);
        //WAITING
        System.out.println(thread.getState());
    }
}

四.TIMED_WAITING

定义：线程处于等待状态

 等待其他线程执行完毕(join)

 其他线程来唤醒(notify)

 等待一定的时间后自动唤醒

public class TIMED_WAITING {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread thread = new Thread(()->{
            synchronized (locker){
                try {
                    //有时间参数的wait
                    locker.wait(10000000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        thread.start();
        Thread.sleep(100);
        //
        System.out.println(thread.getState());
    }
}

五.BLOCKED

定义：线程竞争锁对象失败进入BLOCKED(锁竞争)状态

public class BLOCKED {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread thread1 = new Thread(()->{
            synchronized (locker){
                try {
                    Thread.sleep(1000000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        thread1.start();
        //thread1先拿到locker锁对象
        Thread thread2 = new Thread(()->{
            while (true) {
                synchronized (locker) {
                    System.out.println("Hello Thread2");
                }
            }
        });
        thread2.start();
        //sleep(1000)的作用是让thread2有足够用的时间执行到synchronized
        Thread.sleep(100);
        //获取线程状态
        //BLOCKED
        System.out.println(thread2.getState());
    }
}

六.TERMINATED

定义：线程执行完毕或者因异常退出

public class TERMINATED {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{});
        thread.start();
        //等待线程执行完毕
        thread.join();
        //TERMINATED
        System.out.println(thread.getState());
    }
}