线程的状态转换以及用代码证明（看此一篇即可，带图，带代码验证）

飞熊 • 2023年4月19日下午4:19 • 技术随笔 • 阅读 272

背景

带你了解Java中的线程状态，有图，有代码展示，全是干货。

概述

你看Thread类里的State枚举，就是Java线程的状态了。
网上的状态非常多，你看这个枚举比较权威，各种名词，什么可运行状态，就绪状态，乱七八糟的，记英文即可。

new：刚 new 出来的线程还未 start() 就是 new 状态
terminated：线程将代码运行完毕了就是 terminated 状态
timed_waiting：timed是 “带有时间的” 的意思。带有时间的等待，比如常用的sleep(millis)
waiting：不带时间的等待，比如 join()、wait() 都是
blocked：这个比如需要锁，拿不到，就进入了blocked状态。比如synchronized块获取不到锁而被阻塞了

关于runnable状态，其实是最让人迷惑的
一般人都会有疑惑 “runnable好像描述得不准确，runnable从英文单词来看表示可运行，感觉runnable更加贴近于常说的ready（可运行）状态，另外难道没有运行中的状态吗？”

Thread$State里的runnable，其实是包含两种状态的，一种是还未被CPU挑选中的所谓的可运行状态（ready)，另一种是已经被CPU挑中的正在运行的状态（running）。

PS：其实有一种观点，认为Thread$State里的runnable有3种状态：可运行、正在运行，以及阻塞状态。这里的 “阻塞状态” 是操作系统层面的阻塞，并不是枚举里的blocked状态。操作系统里的 “阻塞状态” 也归类为runnable。

操作系统的阻塞状态指的是什么呢？指的，比如读取文件的时候的阻塞状态

状态转换和线程API的对应图

代码获取线程里的各种状态

/**
 * 用一个类来演示线程的各种状态 Thread$State (API层面的线程的状态可以从这个枚举中查看）
 */
public class T05_ThreadState {
    public static void main(String[] args) {
        // new
        Thread t1 = new Thread(() -> {
        }, "t1");

        // runnable
        Thread t2 = new Thread(() -> {
            while (true) {

            }
        }, "t2");
        t2.start();

        // timed_waiting
        Thread t3 = new Thread(() -> {
            try {
                Thread.sleep(100*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t3");
        t3.start();

        // waiting
        Thread t4 = new Thread(() -> {
            try {
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t4");
        t4.start();


        // blocked
        Thread keepLock = new Thread(() -> {
            synchronized (T05_ThreadState.class) {
                while (true) {

                }
            }
        }, "keepLock");
        keepLock.start();

        // 主线程先睡一下，让keepLock先获得锁
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Thread t5 = new Thread(() -> {
            synchronized (T05_ThreadState.class) {

            }
        }, "t5");
        t5.start();

        // terminated
        Thread t6 = new Thread(() -> {
            System.out.println("end");
        }, "t6");
        t6.start();

        // 睡一下，让 t6 运行完毕以便得到terminated状态
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        System.out.println(t1.getState());// new
        System.out.println(t2.getState());// runnable
        System.out.println(t3.getState());// timed_waiting
        System.out.println(t4.getState());// waiting
        System.out.println(t5.getState());// blocked
        System.out.println(t6.getState());// terminated
    }
}