面试突击:说一下线程生命周期,以及转换过程?

开发 后端
线程的生命周期指的是线程从创建到销毁的整个过程,Java 线程的生命周期和上面说的生命周期是不同的,它有 6 种状态。

作者 | 磊哥

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

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

线程的生命周期指的是线程从创建到销毁的整个过程,通常情况下线程的生命周期有以下 5 种:

  • 初始状态
  • 可运行状态
  • 运行状态
  • 休眠状态
  • 终止状态

它们的状态转换如下图所示:

Java 线程生命周期

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

  1. NEW(初始化状态)
  2. RUNNABLE(可运行/运行状态)
  3. BLOCKED(阻塞状态)
  4. WAITING(无时限等待状态)
  5. TIMED_WAITING(有时限等待状态)
  6. 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面试真题解析
相关推荐

2022-09-05 07:06:59

BeanSpring

2022-03-09 07:35:24

线程池线程参数

2022-06-06 15:33:20

线程Java释放锁

2021-06-02 11:25:18

线程池Java代码

2022-09-27 21:14:54

Spring事务传播机制

2022-06-29 11:01:05

MySQL事务隔离级别

2010-07-14 10:48:37

Perl线程

2023-11-29 16:38:12

线程池阻塞队列开发

2022-05-18 07:43:09

Exchange交换器JUC

2009-06-18 13:32:39

Java线程生命周期

2012-01-16 09:00:56

线程

2021-07-28 10:08:19

类加载代码块面试

2022-01-13 06:59:40

HashMap底层面试

2009-06-29 18:03:15

Java多线程线程的生命周期

2020-06-10 07:38:30

Spring框架周期

2010-07-14 10:59:15

Perl线程

2023-10-26 08:25:35

Java线程周期

2022-07-20 07:29:55

TCPIP协议

2015-07-08 16:28:23

weak生命周期

2022-04-19 07:20:24

软件开发安全生命周期SSDLC应用安全
点赞
收藏

51CTO技术栈公众号