线程状态
线程在执行过程中，状态并不是一层不变的。
线程的6种状态
既然线程的状态是会变化的，那么我们首先要了解线程有哪些状态。
在java.lang.Thread类中，定义了线程的6个状态：
-
NEW
线程已创建，尚未启动。
-
RUNNABLE
线程正在执行；或线程可执行，但是等待来自操作系统的其他资源，如CPU。
-
BLOCKED
线程等待监视器锁。
-
WAITING
线程等待另一个线程去执行一个动作，收到通知后继续执行。
发生以下调用时触发：
Object#wait()，无超时；
Thread#join()，无超时；
LockSupport#park()；
-
TIMED_WAITING
线程等待另一个线程去执行一个动作，并指定等待时间，收到通知或超过等待时间后继续执行。
发生以下调用时触发：
- Thread#sleep；
- Object#wait()，有超时；
- Thread#join，有超时；
- LockSupport#parkNanos()；
- LockSupport#parkUtil()；
-
TERMINATED
线程已完成执行，终止退出。
很明显，线程新建时为NEW，退出时为TERMINATED。但是中间会经历哪些状态呢？这些状态之间是如何变化的呢？
线程之状态变化
下图展示了一个线程在其生命周期中可能经历的所有状态，并标明了这些状态之间的转换条件。
image
从图中可以看出，一个线程的生命周期中可能经历的状态变化共有4种：
- NEW -> RUNNABLE -> TERMINATED
- NEW -> RUNNABLE -> WAITING -> RUNNABLE -> TERMINATED
- NEW -> RUNNABLE -> TIMED_WAITING -> RUNNABLE -> TERMINATED
- NEW -> RUNNABLE -> BLOCKED -> RUNNABLE -> TERMINATED
线程的基本生命周期为NEW->RUNNABLE->TERMINATED（新建->运行->退出）。在执行过程中还可能进入阻塞或等待状态，然后从阻塞或等待状态恢复，继续执行，这个过程可能重复多次。
下面我们使用上文中提到的会触发线程状态改变的API，对线程执行过程中所有可能经历的状态进行模拟验证。
import java.util.concurrent.locks.LockSupport;
public class ThreadState {
public static void main(String[] args) throws InterruptedException {
// 第一种：新建->运行->终止
System.out.println("第一种：新建->运行->终止");
Thread thread1 = new Thread(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName() + "执行了");
}
}, "thread1");
printState(thread1);
thread1.start();
printState(thread1);
// 等待thread1执行完毕
Thread.sleep(1000L);
printState(thread1);
System.out.println();
// 第二种：新建->运行->等待->运行->终止
System.out.println("第二种：新建->运行->等待->运行->终止");
Thread thread2 = new Thread(new Runnable() {
public void run() {
// 挂起当前线程
LockSupport.park();
printState(Thread.currentThread());
System.out.println(Thread.currentThread().getName() + "执行了");
}
}, "thread2");
printState(thread2);
thread2.start();
printState(thread2);
// 等待thread2挂起
Thread.sleep(200);
printState(thread2);
// 唤醒thread2
LockSupport.unpark(thread2);
// 等待thread2执行完毕
Thread.sleep(1000);
printState(thread2);
System.out.println();
// 第三种：新建->运行->计时等待->运行->终止
System.out.println("第三种：新建->运行->计时等待->运行->终止");
Thread thread3 = new Thread(new Runnable() {
public void run() {
try {
// 当前线程睡眠1s
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
printState(Thread.currentThread());
System.out.println(Thread.currentThread().getName() + "执行了");
}
}, "thread3");
printState(thread3);
thread3.start();
printState(thread3);
// 等待thread3进入休眠
Thread.sleep(200);
printState(thread3);
// 等待thread3执行完毕
Thread.sleep(2000);
printState(thread3);
System.out.println();
// 第四种：新建->运行->阻塞->运行->终止
System.out.println("第四种：新建->运行->阻塞->运行->终止");
Thread thread4 = new Thread(new Runnable() {
public void run() {
synchronized (ThreadState.class) {
printState(Thread.currentThread());
System.out.println(Thread.currentThread().getName() + "执行了");
}
}
}, "thread4");
printState(thread4);
// 主线程先拿到锁，再启动thread4
synchronized (ThreadState.class) {
thread4.start();
printState(thread4);
// 等待200ms
Thread.sleep(200);
printState(thread4);
}
// 等待thread4执行完毕
Thread.sleep(1000);
printState(thread4);
}
private static void printState(Thread thread) {
System.out.println(thread.getName() + "当前状态：" + thread.getState());
}
}
运行main()方法，控制台输出如下：
第一种：新建->运行->终止
thread1当前状态：NEW
thread1当前状态：RUNNABLE
thread1执行了
thread1当前状态：TERMINATED
第二种：新建->运行->等待->运行->终止
thread2当前状态：NEW
thread2当前状态：RUNNABLE
thread2当前状态：WAITING
thread2当前状态：RUNNABLE
thread2执行了
thread2当前状态：TERMINATED
第三种：新建->运行->计时等待->运行->终止
thread3当前状态：NEW
thread3当前状态：RUNNABLE
thread3当前状态：TIMED_WAITING
thread3当前状态：RUNNABLE
thread3执行了
thread3当前状态：TERMINATED
第四种：新建->运行->阻塞->运行->终止
thread4当前状态：NEW
thread4当前状态：RUNNABLE
thread4当前状态：BLOCKED
thread4当前状态：RUNNABLE
thread4执行了
thread4当前状态：TERMINATED
