关于php:面试突击说一下线程生命周期以及转换过程

线程的生命周期指的是线程从创立到销毁的整个过程，通常状况下线程的生命周期有以下 5 种：

初始状态
可运行状态
运行状态
休眠状态
终止状态
它们的状态转换如下图所示：

Java 线程生命周期
Java 线程的生命周期和下面说的生命周期是不同的，它有以下 6 种状态：

NEW（初始化状态）
RUNNABLE（可运行/运行状态）
BLOCKED（阻塞状态）
WAITING（无时限期待状态）
TIMED_WAITING（有时限期待状态）
TERMINATED（终止状态）
咱们能够在 Thread 的源码中能够找到这 6 种状态，如下所示：

当然你也能够应用 Java 代码，来打印所有的线程状态，如下代码所示：

for (Thread.State value : Thread.State.values()) {    System.out.println(value);}复制代码

以上程序的执行后果如下图所示：

生命周期转换
接下来咱们聊聊 Java 线程生命周期的转换过程。

1.从 NEW 到 RUNNABLE
当咱们创立一个线程的时候，也就是 new Thread 的时候，此时线程是 NEW 状态，如下代码所示：

// 创立线程Thread thread = new Thread(new Runnable() {    @Override    public void run() {        // ...    }});// 获取线程状态Thread.State state = thread.getState();System.out.println(state);复制代码

以上程序的执行后果如下图所示：

然而调用了线程的 start 办法之后，线程的状态就从 NEW 变成了 RUNNABLE，如下代码所示：

// 创立线程Thread thread = new Thread(new Runnable() {    @Override    public void run() {        // 获取到以后执行的线程        Thread currThread = Thread.currentThread();        // 获取线程状态        Thread.State state = currThread.getState();        // 打印线程状态        System.out.println(state);    }});thread.start()

;
复制代码
以上程序的执行后果如下图所示：

2.从 RUNNABLE 到 BLOCKED
当线程中的代码排队执行 synchronized 时，线程就会从 RUNNABLE 状态变为 BLOCKED 阻塞状态，如下代码所示：

// 创立线程Thread thread = new Thread(new Runnable() {    @Override    public void run() {        try {            // 期待 100 毫秒            Thread.sleep(100);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("排队应用锁");        synchronized (ThreadStates.class) {        }    }});thread.start();// 让主线程先失去锁synchronized (ThreadStates.class) {    // 获取线程状态    Thread.State state = thread.getState();    // 打印线程状态    System.out.println("首次获取线程状态：" + state);    // 休眠 1s    try {        Thread.sleep(1000);    } catch (InterruptedException e) {        e.printStackTrace();    }    // 再次获取线程状态    state = thread.getState();    // 打印线程状态    System.out.println("第二次获取线程状态：" + state);}复制代码

以上程序的执行后果如下图所示：

当线程获取到 synchronized 锁之后，就会从 BLOCKED 状态转变为 RUNNABLE 状态。

3.从 RUNNABLE 到 WAITTING
线程调用 wait() 办法之后，就会从 RUNNABLE 状态变为 WAITING 无时限期待状态，如下所示：

// 创立线程Thread thread = new Thread(new Runnable() {    @Override    public void run() {        synchronized (this) {            try {                // 线程休眠                this.wait();            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }});// 启动线程thread.start();// 获取线程状态Thread.State state = thread.getState();// 打印线程状态System.out.println("首次获取线程状态：" + state);// 休眠 1stry {    Thread.sleep(1000);} catch (InterruptedException e) {    e.printStackTrace();}// 获取线程状态state = thread.getState();// 打印线程状态System.out.println("第二次获取线程状态：" + state);复制代码

以上程序的执行后果如下图所示：

当调用了 notify/notifyAll 办法之后，线程会从 WAITING 状态变成 RUNNABLE 状态，如下代码所示：

Object lock = new Object();// 创立线程Thread thread = new Thread(new Runnable() {    @Override    public void run() {        synchronized (lock) {            try {                // 线程休眠                lock.wait();                // 获取以后线程状态                Thread.State state = Thread.currentThread().getState();                // 打印线程状态                System.out.println("获取线程状态：" + state);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }});// 启动线程thread.start();// 获取线程状态Thread.State state = thread.getState();// 打印线程状态System.out.println("首次获取线程状态：" + state);// 休眠 1stry {    Thread.sleep(100);} catch (InterruptedException e) {    e.printStackTrace();}// 获取线程状态state = thread.getState();// 打印线程状态System.out.println("第二次获取线程状态：" + state);// 唤醒 thread 线程synchronized (lock) {    lock.notify();}复制代码

以上程序的执行后果如下图所示：

4.从 RUNNABLE 到 TIMED_WATTING
当调用带超时工夫的期待办法时，如 sleep(xxx)，线程会从 RUNNABLE 状态变成 TIMED_WAITING 有时限状态，如下代码所示：

// 创立线程Thread thread = new Thread(new Runnable() {    @Override    public void run() {        try {            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }    }});// 启动线程thread.start();// 获取线程状态Thread.State state = thread.getState();// 打印线程状态System.out.println("首次获取线程状态：" + state);// 休眠 1stry {    Thread.sleep(100);} catch (InterruptedException e) {    e.printStackTrace();}// 获取线程状态state = thread.getState();// 打印线程状态System.out.println("第二次获取线程状态：" + state);复制代码

以上程序的执行后果如下图所示：

当超过了超时工夫之后，线程就会从 TIMED_WAITING 状态变成 RUNNABLE 状态，实现代码如下：

// 创立线程Thread thread = new Thread(new Runnable() {    @Override    public void run() {        try {            Thread.sleep(1000);            // 获取以后线程状态            Thread.State state = Thread.currentThread().getState();            // 打印线程状态            System.out.println("获取线程状态：" + state);        } catch (InterruptedException e) {            e.printStackTrace();        }    }});// 启动线程thread.start();// 获取线程状态Thread.State state = thread.getState();// 打印线程状态System.out.println("首次获取线程状态：" + state);// 休眠 1stry {    Thread.sleep(100);} catch (InterruptedException e) {    e.printStackTrace();}// 获取线程状态state = thread.getState();// 打印线程状态System.out.println("第二次获取线程状态：" + state);复制代码

以上程序的执行后果如下图所示：

5.RUNNABLE 到 TERMINATED
线程执行完之后，就会从 RUNNABLE 状态变成 TERMINATED 销毁状态，如下代码所示：

// 创立线程Thread thread = new Thread(new Runnable() {    @Override    public void run() {        // 获取以后线程状态        Thread.State state = Thread.currentThread().getState();        // 打印线程状态        System.out.println("获取线程状态：" + state);    }});// 启动线程thread.start();// 期待 100ms，待线程执行完Thread.sleep(100);// 获取线程状态Thread.State state = thread.getState();// 打印线程状态System.out.println("线程状态：" + state);复制代码

以上程序的执行后果如下图所示：

总结
Java 中线程的生命周期有 6 种：NEW（初始化状态）、RUNNABLE（可运行/运行状态）、BLOCKED（阻塞状态）、WAITING（无时限期待状态）、TIMED_WAITING（有时限期待状态）、TERMINATED（终止状态）。线程生命周期的转换流程如下图所示：

最初
如果你感觉此文对你有一丁点帮忙，点个赞。或者能够退出我的开发交换群：1025263163互相学习，咱们会有业余的技术答疑解惑

如果你感觉这篇文章对你有点用的话，麻烦请给咱们的开源我的项目点点star:http://github.crmeb.net/u/defu不胜感激 ！

PHP学习手册：https://doc.crmeb.com
技术交换论坛：https://q.crmeb.com