线程状态到底是5种还是六种?傻傻分不清楚

news2025/2/25 17:27:03

从操作系统层面上描述线程状态

从javaAPI层面上理解线程的6种状态

线程的状态转换.

NEW --> RUNNABLE

1.RUNNABLE <--> WAITING

2.RUNNABLE <--> WAITING

3.RUNNABLE <--> WAITING

1.RUNNABLE <--> TIMED_WAITING

2.RUNNABLE <--> TIMED_WAITING

3. RUNNABLE <--> TIMED_WAITING

4.RUNNABLE <--> TIMED_WAITING

RUNNABLE <--> BLOCKED

RUNNABLE <--> TERMINATED

从操作系统层面上描述线程状态

初始状态 : 仅仅是语言层面创建了线程对象,还没有与操作系统相关联.比如new 了一个Thread对象还没有调用start方法
可运行状态 : 也可以理解为就绪状态,该线程已经被创建了,与操作系统相关联,可以由CPU调度,但是线程调度器还没有给该线程分配CPU时间片
运行状态 : 给该线程分配了CPU时间片,线程处于正在运行的状态

- 这里运行状态和可运行状态是能进行上下文切换的,当CPU时间片用完了,线程就会从运行状态变为可运行状态.,导致线程上下文切换

阻塞状态 : 该线程调用了一些阻塞API,如BIO读写文件,这时该线程实际不会用到CPU,就会导致上下文切换,从运行状态变为阻塞状态.线程调度器不会分配给[阻塞状态线程]CPU时间片的,但是会分配给可运行状态的线程. 当读写文件操作完毕,会由操作系统来唤醒阻塞状态的线程, 就会从阻塞状态变为可运行状态
终止状态 : 当当前线程的所有代码执行完成之后,表示线程已经执行完毕,生命周期已经结束了,不会再转换为其他状态.

从javaAPI层面上理解线程的6种状态

6种状态是JavaAPI层面上的.

根据Thread.State 枚举 ,分为6种状态.

NEW : 仅仅是语言层面创建了线程对象,还没有与操作系统相关联.比如new 了一个Thread对象还没有调用start方法
RUNNABLE : JavaAPI层面上状态涵盖了操作系统层面的[可运行状态],[运行状态] 和[阻塞状态]
阻塞状态在Java里面细分为 BLOKED,WAITING,TIMED_WAITING
BLOKED : 当t线程调用synchronized(obj) 获取对象锁时竞争失败,会进入BLOCKED状态
WAITING : 当调用线程的join方法,LockSupport.park()方法或者用synchronized(obj)获取了对象锁后,调用obj.wait()方法时.
TIMED_WAITING : 当用synchronized获取对象锁后,调用wait(long n)方法时候,当调用join(long n) ,调用sleep(long n),或者调用LockSupport的有时限的方法时
TERMINATED : 当当前线程的所有代码执行完成之后,表示线程已经执行完毕,生命周期已经结束了,不会再转换为其他状态.

利用Java代码来演示一下JavaAPI层面的6种状态

@Slf4j(topic = "c.TestState")
public class TestState {

    public static void main(String[] args) {
        //NEW 状态 -> 没有调用start方法->只创建了线程对象没有启动该线程
        Thread t1 = new Thread(() -> {
            log.debug("running...");
        },"t1");
        //Runnable状态中的可运行状态
        Thread t2 = new Thread(() -> {
            while(true) {

            }
        },"t2");
        //TIMED_WAITING状态
        Thread t3 = new Thread(()->{
            synchronized (TestState.class) {
                try {
                    Thread.sleep(100000000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t3");
        //WAITING状态
        Thread t4 = new Thread(()->{
            try {
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t4");
        //TERMINATED->终止状态
        Thread t5 = new Thread(()->{
           log.debug("running....");
        },"t5");
        //BLOCKED 状态
        Thread t6 = new Thread(()->{//后获取到锁
           synchronized (TestState.class) {
               log.debug("running");
           }
        },"t6");
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        t6.start();
        System.out.println("t1 : " + t1.getState());
        System.out.println("t2 : " + t2.getState());
        System.out.println("t3 : " + t3.getState());
        System.out.println("t4 : " + t4.getState());
        System.out.println("t5 : " + t5.getState());
        System.out.println("t6 : " + t6.getState());
    }
}

线程的状态转换.

NEW --> RUNNABLE

当调用了 t.start()方法的时候,由NEW --> RUNNABLE