共计 4508 个字符,预计需要花费 12 分钟才能阅读完成。
线程的生命周期指的是线程从创立到销毁的整个过程,通常状况下线程的生命周期有以下 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(终止状态)。线程生命周期的转换流程如下图所示:
参考资料
《Java 并发编程实战》
是非审之于己,毁誉听之于人,得失安之于数。
公众号:Java 面试真题解析
面试合集:https://gitee.com/mydb/interview