内容摘要：作者 | 磊哥来源 | Java面试真题解析(ID：aimianshi666)转载请联系授权(微信ID：GG_Stone)线程的生命周期指的是线程从创建到销毁的整个过程，通常情况下线程的生命周期有以下

作者 | 磊哥

来源 | Java面试真题解析(ID：aimianshi666)

转载请联系授权(微信ID：GG_Stone)

线程的面试生命周期指的是线程从创建到销毁的整个过程，通常情况下线程的突击生命周期有以下 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);

// 休眠 1s

try {

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);

// 休眠 1s

try {

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);

// 休眠 1s

try {

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);

// 休眠 1s

try {

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(终止状态)。线程生命周期的转换流程如下图所示：

亿华云