关于java:面经手册-第20篇Thread-线程状态转换方法使用原理分析

作者：小傅哥
<br/> 博客：https://bugstack.cn
<br/>Github：https://github.com/fuzhengwei/CodeGuide/wiki

积淀、分享、成长，让本人和别人都能有所播种！????

考不罕用的、考你不会的、考你疏忽的，才是考试！

大部分考试考的，根本都是不怎么用的。例外的咱们不说???? 就像你做程序开发，尤其在 RPC+MQ+ 分库分表，其实很难呈现让你用一个机器实例编写多线程压迫 CPU 性能。很多时候是扔出一个 MQ，异步生产了。如果没有资源竞争，例如库表秒杀，那么其实你的确很难接触多并发编程以及锁的应用。

但！凡有例外，比方你须要开发一个数据库路由中间件，那么就必定会呈现在一台利用实例上调配数据库资源池的状况，如果呈现竞争就要正当分配资源。如此，相似这样的中间件开发，就会波及到一些更外围底层的技术的利用。

所以，有时候不是 没用 ，而是你没有用。

谢飞机，小记！ 线程我玩定了，面试也拦不住我，我说的！

谢飞机：嘿，你好哇，我是谢飞机！

面试官：好，明天电话面试，你筹备好了？

谢飞机：筹备好了，嘿嘿！

面试官：嗯，我看你简历里写了不少线程的货色，看来理解的不错。问你一个线程吧那就，线程之间状态是怎么转换的？

谢飞机：扒拉扒拉，扒拉扒拉！

面试官：嗯，还不错。那 yield 办法是怎么应用的。

谢飞机：嗯！如同是让出 CPU。具体的没怎么用过！

面试官：做做测试，验证下，下次问你。

Java 的线程状态形容在枚举类 java.lang.Thread.State 中，共包含如下五种状态：

public enum State {NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED;}

这五种状态形容了一个线程的生命周期，其实这种状态码的定义在咱们日常的业务开发中，也经常出现。比方：一个流动的提交、审核、回绝、批改、通过、运行、敞开等，是相似的。那么线程的状态是通过下图的形式进行流转的，如图 20-1

New：新创建的一个线程，处于期待状态。
Runnable：可运行状态，并不是曾经运行，具体的线程调度各操作系统决定。在 Runnable 中蕴含了 Ready、Running 两个状态，当线程调用了 start() 办法后，线程则处于就绪 Ready 状态，期待操作系统调配 CPU 工夫片，调配后则进入 Running 运行状态。此外当调用 yield() 办法后，只是谦让的容许以后线程让出 CPU，但具体让不让不肯定，由操作系统决定。如果让了，那么以后线程则会处于 Ready 状态持续竞争 CPU，直至执行。
Timed_waiting：指定工夫内让出 CPU 资源，此时线程不会被执行，也不会被系统调度，直到等待时间到期后才会被执行。下列办法都能够触发：Thread.sleep、Object.wait、Thread.join、LockSupport.parkNanos、LockSupport.parkUntil。
Wating：可被唤醒的期待状态，此时线程不会被执行也不会被系统调度。此状态能够通过 synchronized 取得锁，调用 wait 办法进入期待状态。最初通过 notify、notifyall 唤醒。下列办法都能够触发：Object.wait、Thread.join、LockSupport.park。
Blocked：当产生锁竞争状态下，没有取得锁的线程会处于挂起状态。例如 synchronized 锁，先取得的先执行，没有取得的进入阻塞状态。
Terminated：这个是终止状态，从 New 到 Terminated 是不可逆的。个别是程序流程失常完结或者产生了异样。

这里参考枚举State 类的英文正文理解了每一个状态码的含意，接下来咱们去尝试操作线程办法，把这些状态体现进去。

Thread thread = new Thread(() -> {});
System.out.println(thread.getState());

// NEW

这个状态很简略，就是线程创立还没有启动时就是这个状态。

Thread thread = new Thread(() -> {});
// 启动
thread.start();
System.out.println(thread.getState());

// RUNNABLE

创立的线程启动后 start()，就会进入 RUNNABLE 状态。但此时并不一定在执行，而是说这个线程曾经就绪，能够竞争 CPU 资源。

Object obj = new Object();
new Thread(() -> {synchronized (obj) {
        try {Thread.sleep(10000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
}).start();

Thread thread = new Thread(() -> {synchronized (obj) {
        try {obj.wait();
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
});

thread.start();
while (true) {Thread.sleep(1000);
    System.out.println(thread.getState());
}

// BLOCKED
// BLOCKED
// BLOCKED

这段代码略微有点长，次要是为了让两个线程产生锁竞争。
第一个线程，synchronized 获取锁后休眠，不开释锁。
第二个线程，synchronized 获取不到锁，会被挂起。
那么最初的输入后果就会是，BLOCKED

Object obj = new Object();
Thread thread = new Thread(() -> {synchronized (obj) {
        try {obj.wait();
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
});

thread.start();

while (true) {Thread.sleep(1000);
    System.out.println(thread.getState());
}

// WAITING
// WAITING
// WAITING

只有在 synchronized 代码块或者润饰的办法中，调用 wait 办法，又没有被 notify 就会进入 WAITING 状态。
另外 Thread.join 源码中也是调用的 wait 办法，所以也会让线程进入期待状态。

Object obj = new Object();
Thread thread = new Thread(() -> {synchronized (obj) {
        try {Thread.sleep(100000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
    }
});
thread.start();

while (true) {Thread.sleep(1000);
    System.out.println(thread.getState());
}

// TIMED_WAITING
// TIMED_WAITING
// TIMED_WAITING

有了下面状态获取的比照，这个状态的获取就没什么难度了。只有改成 Thread.sleep(100000); 就能够了。

Thread thread = new Thread(() -> {});
thread.start();

System.out.println(thread.getState());
System.out.println(thread.getState());
System.out.println(thread.getState());

// RUNNABLE
// TERMINATED
// TERMINATED

这个就比较简单了，只有一个线程运行完，它的生命周期完结了，就进入了 TERMINATED 状态。

个别状况下 Thread 中最罕用的办法就是 start 启动，除此之外一些其余办法可能在平时的开发中用的不多，但这些办法在一些框架中却经常出现。因而只理解它们的概念，然而却短少一些实例来参考！ 接下来咱们就来做一些案例来验证这些办法，包含：yield、wait、notify、join。

yield 办法让出 CPU，但不肯定，肯定让出！。这种可能会用在一些同时启动的线程中，依照优先级保障重要线程的执行，也能够是其余一些非凡的业务场景（例如这个线程内容很耗时，又不那么重要，能够放在前面）。

为了验证这个办法，咱们做一个例子：启动 50 个线程进行，每个线程都进行 1000 次的加和计算。其中 10 个线程会执行让出 CPU 操作。那么，如果让出 CPU 那 10 个线程的计算加和工夫都比拟长，阐明的确在进行让出操作。

案例代码

private static volatile Map<String, AtomicInteger> count = new ConcurrentHashMap<>();
static class Y implements Runnable {
    private String name;
    private boolean isYield;
    public Y(String name, boolean isYield) {
        this.name = name;
        this.isYield = isYield;
    }
    @Override
    public void run() {long l = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {if (isYield) Thread.yield();
            AtomicInteger atomicInteger = count.get(name);
            if (null == atomicInteger) {count.put(name, new AtomicInteger(1));
                continue;
            }
            atomicInteger.addAndGet(1);
            count.put(name, atomicInteger);
        }
        System.out.println("线程编号：" + name + "执行实现耗时：" + (System.currentTimeMillis() - l) + "(毫秒)" + (isYield ? "让出 CPU----------------------" : "不让 CPU"));
    }
}

public static void main(String[] args) {for (int i = 0; i < 50; i++) {if (i < 10) {new Thread(new Y(String.valueOf(i), true)).start();
            continue;
        }
        new Thread(new Y(String.valueOf(i), false)).start();}
}

测试后果

线程编号：10 执行实现耗时：2 (毫秒)不让 CPU
线程编号：11 执行实现耗时：2 (毫秒)不让 CPU
线程编号：15 执行实现耗时：1 (毫秒)不让 CPU
线程编号：14 执行实现耗时：1 (毫秒)不让 CPU
线程编号：19 执行实现耗时：1 (毫秒)不让 CPU
线程编号：18 执行实现耗时：1 (毫秒)不让 CPU
线程编号：22 执行实现耗时：0 (毫秒)不让 CPU
线程编号：26 执行实现耗时：0 (毫秒)不让 CPU
线程编号：27 执行实现耗时：1 (毫秒)不让 CPU
线程编号：30 执行实现耗时：0 (毫秒)不让 CPU
线程编号：31 执行实现耗时：0 (毫秒)不让 CPU
线程编号：34 执行实现耗时：1 (毫秒)不让 CPU
线程编号：12 执行实现耗时：1 (毫秒)不让 CPU
线程编号：16 执行实现耗时：1 (毫秒)不让 CPU
线程编号：13 执行实现耗时：1 (毫秒)不让 CPU
线程编号：17 执行实现耗时：1 (毫秒)不让 CPU
线程编号：20 执行实现耗时：0 (毫秒)不让 CPU
线程编号：23 执行实现耗时：0 (毫秒)不让 CPU
线程编号：21 执行实现耗时：0 (毫秒)不让 CPU
线程编号：25 执行实现耗时：1 (毫秒)不让 CPU
线程编号：24 执行实现耗时：1 (毫秒)不让 CPU
线程编号：28 执行实现耗时：0 (毫秒)不让 CPU
线程编号：38 执行实现耗时：0 (毫秒)不让 CPU
线程编号：39 执行实现耗时：0 (毫秒)不让 CPU
线程编号：37 执行实现耗时：1 (毫秒)不让 CPU
线程编号：40 执行实现耗时：0 (毫秒)不让 CPU
线程编号：44 执行实现耗时：0 (毫秒)不让 CPU
线程编号：36 执行实现耗时：1 (毫秒)不让 CPU
线程编号：42 执行实现耗时：1 (毫秒)不让 CPU
线程编号：45 执行实现耗时：1 (毫秒)不让 CPU
线程编号：43 执行实现耗时：1 (毫秒)不让 CPU
线程编号：46 执行实现耗时：0 (毫秒)不让 CPU
线程编号：47 执行实现耗时：0 (毫秒)不让 CPU
线程编号：35 执行实现耗时：0 (毫秒)不让 CPU
线程编号：33 执行实现耗时：0 (毫秒)不让 CPU
线程编号：32 执行实现耗时：0 (毫秒)不让 CPU
线程编号：41 执行实现耗时：0 (毫秒)不让 CPU
线程编号：48 执行实现耗时：1 (毫秒)不让 CPU
线程编号：6 执行实现耗时：15 (毫秒)让出 CPU----------------------
线程编号：7 执行实现耗时：15 (毫秒)让出 CPU----------------------
线程编号：49 执行实现耗时：2 (毫秒)不让 CPU
线程编号：29 执行实现耗时：1 (毫秒)不让 CPU
线程编号：2 执行实现耗时：17 (毫秒)让出 CPU----------------------
线程编号：1 执行实现耗时：11 (毫秒)让出 CPU----------------------
线程编号：4 执行实现耗时：15 (毫秒)让出 CPU----------------------
线程编号：8 执行实现耗时：12 (毫秒)让出 CPU----------------------
线程编号：5 执行实现耗时：12 (毫秒)让出 CPU----------------------
线程编号：9 执行实现耗时：12 (毫秒)让出 CPU----------------------
线程编号：0 执行实现耗时：21 (毫秒)让出 CPU----------------------
线程编号：3 执行实现耗时：21 (毫秒)让出 CPU----------------------

从测试后果能够看到，那些让出 CPU 的，执行完计算曾经在 10 毫秒以上，阐明咱们的测试是成果的。

wait 和 notify/nofityall，是一对办法，有一个期待，就会有一个叫醒，否则程序就夯在那不动了。对于这部分会应用到的 synchronized 在之前小傅哥有深刻的源码剖析，讲到它是怎么加锁在对象头的，如果你遗记了能够翻翻看《synchronized 解毒，分析源码深度剖析！》

接下来咱们模仿鹿鼎记·丽春院，清倌喝茶吟诗聊风月日常。当有达官贵人来时，须要调配清倌给大老爷。两头会有一些期待、叫醒操作。只为让你更好的记住这样的案例，不要想歪喽。清倌人即是只卖艺欢场人，喊麦的。

案例代码

public class 丽春院 {public static void main(String[] args) {老鸨 鸨子 = new 老鸨();

        清倌 miss = new 清倌(鸨子);
        客官 guest = new 客官(鸨子);

        Thread t_miss = new Thread(miss);
        Thread t_guest = new Thread(guest);

        t_miss.start();
        t_guest.start();}

}

class 清倌 implements Runnable {

    老鸨 鸨子;

    public 清倌(老鸨 鸨子) {this. 鸨子 = 鸨子;}

    @Override
    public void run() {
        int i = 1;
        while (true) {
            try {Thread.sleep(1000);
            } catch (InterruptedException e1) {e1.printStackTrace();
            }
            if (i == 1) {
                try {鸨子. 在岗清倌("苍原野子", "500 日元");
                } catch (InterruptedException e) {e.printStackTrace();
                }
            } else {
                try {鸨子. 在岗清倌("花田岗子", "800 日元");
                } catch (InterruptedException e) {e.printStackTrace();
                }
            }
            i = (i + 1) % 2;
        }
    }

}

class 客官 implements Runnable {

    老鸨 鸨子;

    public 客官(老鸨 鸨子) {this. 鸨子 = 鸨子;}

    @Override
    public void run() {while (true) {
            try {Thread.sleep(1000);
            } catch (InterruptedException e1) {e1.printStackTrace();
            }
            try {鸨子. 喝茶吟诗聊风月();
            } catch (InterruptedException e) {e.printStackTrace();
            }
        }
    }

}

class 老鸨 {

    private String 清倌 = null;
    private String price = null;
    private boolean 工作状态 = true;

    public synchronized void 在岗清倌(String 清倌, String price) throws InterruptedException {if (! 工作状态)
            wait();// 期待
        this. 清倌 = 清倌;
        this.price = price;
        工作状态 = false;
        notify();// 叫醒}

    public synchronized void 喝茶吟诗聊风月() throws InterruptedException {if (工作状态)
            wait();// 期待
        System.out.println("聊风月：" + 清倌);
        System.out.println("茶水费：" + price);
        System.out.println("" +"  "+"  "+"  "+"  "+"  "+"  "+"  "+"  "+"  "+ 清倌 +" 完事 "+" 筹备 ... ...");
        System.out.println("****************************************");
        工作状态 = true;
        notify();// 叫醒}

}

测试后果

聊风月：苍原野子
茶水费：500 日元
                    苍原野子完事筹备 ... ...
****************************************
聊风月：花田岗子
茶水费：800 日元
                    花田岗子完事筹备 ... ...
****************************************
聊风月：苍原野子
茶水费：500 日元
                    苍原野子完事筹备 ... ...
****************************************

...

成果成果次要体现 wait、notify，这两个办法的应用。我置信你肯定能记住这个例子！

join 是两个线程的合并吗？不是的！

join 是让线程进入 wait，当线程执行结束后，会在 JVM 源码中找到，它执行结束后，其实执行 notify，也就是 期待 和 叫醒 操作。

源码：jdk8u_hotspot/blob/master/src/share/vm/runtime/thread.cpp

void JavaThread::exit(bool destroy_vm, ExitType exit_type) {// Notify waiters on thread object. This has to be done after exit() is called
    // on the thread (if the thread is the last thread in a daemon ThreadGroup the
    // group should have the destroyed bit set before waiters are notified).
    ensure_join(this);
}

static void ensure_join(JavaThread* thread) {
  // 叫醒
  java_lang_Thread::set_thread(threadObj(), NULL);
  lock.notify_all(thread);
}

好的，就是这里！lock.notify_all(thread)，执行到这，就对上了。

案例代码

Thread thread = new Thread(() -> {System.out.println("thread before");
    try {Thread.sleep(3000);
    } catch (Exception e) {e.printStackTrace();
    }
    System.out.println("thread after");
});
thread.start();
System.out.println("main begin！");
thread.join();
System.out.println("main end！");

测试后果

main begin！thread before
thread after
main end！Process finished with exit code 0

首先 join() 是一个 synchronized 办法，外面调用了 wait()，这个过程的目标是让持有这个同步锁的线程进入期待，那么谁持有了这个同步锁呢？答案是主线程，因为主线程调用了 threadA.join()办法，相当于在 threadA.join()代码这块写了一个同步代码块，谁去执行了这段代码呢，是主线程，所以主线程被 wait()了。而后在子线程 threadA 执行结束之后，JVM 会调用 lock.notify_all(thread); 唤醒持有 threadA 这个对象锁的线程，也就是主线程，会继续执行。

这部分验证的次要体现就是加了 thread.join() 后，会影响到输入后果。如果不加，main end！ 会优先 thread after 提前打印进去。
join() 是一个 synchronized 办法，外面调用了 wait() 办法，让持有以后同步锁的线程进入期待状态，也就是主线程。当子线程执行结束后，咱们从源码中能够看到 JVM 调用了 lock.notify_all(thread) 所以唤醒了主线程继续执行。

线程状态和状态的转换也是面试中必问的问题，但除了面试是咱们本人在开发中，如果真的应用线程，是十分有必要理解线程状态是如何转换的。隐隐约约的应用，总会感觉放心，那么你是个好程序员！
线程的一些深刻学习都是在调用本地办法，也就是须要理解到 JVM 层面，能力更加粗浅的见到 c ++ 代码是如何实现这部分逻辑的。
在应用线程的时候肯定要让本人有一个相似多核的脑子，线程一起、生死由你！本章节就扯到这了，很多的常识都是为了整套内容体系的全面，为后续介绍其余常识打下根基。感激！

BATJTMD，大厂招聘，都招什么样 Java 程序员？
Thread.start()，它是怎么让线程启动的呢？
synchronized 解毒，分析源码深度剖析！
volatile 怎么实现的内存可见？没有 volatile 肯定不可见吗？
鹿鼎记 · 韦小宝，丽春院、天地会、入皇宫等五个场景，搭配不同剧情解说多线程和锁，真香！

关于java:面经手册-第20篇Thread-线程状态转换方法使用原理分析

一、前言

二、面试题

三、Thread 状态关系

四、Thread 状态测试

1. NEW

2. RUNNABLE

3. BLOCKED

4. WAITING

5. Timed_waiting

6. Terminated

五、Thread 办法应用

1. yield

2. wait & notify

3. join

六、总结

七、系列举荐