java线程的7种状态

目录

一，理论依据

二，代码演示

（一）：案例一

（二）：案例二

（三）：案例Console打印展示

三，线程7种状态流转图

---

一，理论依据

一般来说面试问道线程都是说的5种状态，但网上的说法又很杂乱，无意间翻看源码，看到如下代码，源码给出的答案是6种：把等待（WAIT)分为两种，一个是定时等待（TIMED_WAITING）时间到就自动唤醒，一个是等待中（WAITING）需要主动唤醒。

 public static State toThreadState(int var0) {
        if ((var0 & 4) != 0) {
            return State.RUNNABLE;
        } else if ((var0 & 1024) != 0) {
            return State.BLOCKED;
        } else if ((var0 & 16) != 0) {
            return State.WAITING;
        } else if ((var0 & 32) != 0) {
            return State.TIMED_WAITING;
        } else if ((var0 & 2) != 0) {
            return State.TERMINATED;
        } else {
            return (var0 & 1) == 0 ? State.NEW : State.RUNNABLE;
        }
    }

但我们知道其中可运行（RUNNABLE）可以分成，CPU调度与挂起状态，RUNNABLE又可以分为两种：CPU调度与挂起状态，分别为两种状态运行（RUNNING）和就绪（READY）。

Thread类的注释：

可运行线程的线程状态。可运行的线程状态正在Java虚拟机中执行，但可能

正在等待来自操作系统的其他资源,例如处理器。

/**
 * Thread state for a runnable thread.  A thread in the runnable
 * state is executing in the Java virtual machine but it may
 * be waiting for other resources from the operating system
 * such as processor.
 */
RUNNABLE,

二，代码演示

由于源码中只提供六种状态：下面只展示6中状态的对应代码，帮助记忆：

（一）：案例一

使用sleep（time）的测试，

 /**
     * 使用sleep（time）的测试体现出3个状态
     * NEW,TIMED_WAITING,TERMINATED
     */
    private static void statTest1(){
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        new Thread(() -> {
            labe: for (;;){
                try {
                    Thread.sleep(200);
                    System.out.println(t1.getState());
                    if(Thread.State.TERMINATED.equals(t1.getState())){
                        break labe;//线程死亡停止
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }).start();
        System.err.println(t1.getState());
        t1.start();
        try {
            t1.join();//让t1先执行，模拟出终结
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

（二）：案例二

生产消费模型中有对应的三个状态：BLOCKED,RUNNABLE,WAITING

    private static class Production extends  Thread{
        Queue<Integer> b ;
        int num = 2;
        Production(Queue<Integer> queue){
            this.b=queue;
        }

        @Override
        public void run() {
            for (;;){
                synchronized(b){
                    while (b.size()>=num){
                        try {
                            b.wait();//产能溢出，等待消费"
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int pnum= new Random().nextInt(10);
                    b.offer(pnum);//生产 "+pnum
                    b.notifyAll();
                }
            }
        }
    }
    private static class Consumption extends  Thread{
        Queue<Integer> b ;
        int num = 2;
        Consumption(Queue<Integer> queue){
            this.b=queue;
        }
        @Override
        public void run() {
            for (;;){
                synchronized(b){
                    while (b.isEmpty()){
                        try {
                            b.wait();//生产供不应求，消费等待
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    b.poll();//消费---
                    b.notifyAll();
                }
            }
        }
    }

    /**
     * 生产消费模型中有对应的三个状态
     * BLOCKED,RUNNABLE,WAITING
     */
    private static void productionAndConsumption(){
        Queue<Integer> q = new LinkedList<>();
        Production p1 = new Production(q);
        Consumption c1 = new Consumption(q);
        Consumption c2 = new Consumption(q);
        new Thread(() -> {
            Set<Thread.State> ts = new LinkedHashSet<>();
            labe: for (;;){
                try {
                    Thread.sleep(500);
                    System.out.println(p1.getState());
                    ts.add(p1.getState());
                    if (ts.size()==3){
                        break labe;//拿到想要的三个状态后停止
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.exit(0);//关闭程序
        }).start();
        p1.start();
        c1.start();
        c2.start();
    }

（三）：案例Console打印展示

NEW
TIMED_WAITING
TIMED_WAITING
BLOCKED
TIMED_WAITING
TIMED_WAITING
WAITING
TERMINATED
WAITING
BLOCKED
WAITING
WAITING

三，线程7种状态流转图