一、线程生命周期与状态
一个线程从创建、运行到终止称为一个生命周期，线程在其生命周期中要经历创建、就绪、运行、阻塞、等待、终止多种状态，这多种状态的转换图如图所示：
当一个线程对象被创建时，状态为New；当线程启动时，进入Runnable状态；当线程运行由于资源或锁被占用时，进入Blocked状态；当线程休眠时，进入等待状态；当线程执行完毕或发生中断异常是时，线程运行结束，进入Terminated状态。
JDK的
Thread类中定义了线程状态的内部枚举类State，如下所示：
public enum State {
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}
1、New
当一个Thread类或其子类使用new关键字声明一个对象实例时，JVM为对象分配堆内存，此时线程处于新建状态，但是线程还没有被运行，即没有被激活。
2、Runnable
处于新建状态的线程通过调用start方法启动后，线程进入就绪状态，这时的线程已经拥有了运行所需的所有条件，将进入线程队列排队等待CPU调度。由于还没有获得CPU时间片，所以启动后不会被立即执行；当获得CPU时间片后，线程由就绪状态转换为运行状态，处于运行状态的线程将执行run方法中定义的操作。
当然，State枚举类中没有对这两个状态加以区分，我们也很难肉眼判断线程是就绪还是运行中，这依赖于操作系统对CPU的时间分片调度。
3、Blocked
线程运行过程中可能由于某些原因让出正在使用的CPU资源，进入阻塞（Blocked）状态，这些情况包括：
- 某些共享资源（如打印机或文件资源等）被占用；
- 等待IO操作；
- 尝试获得锁，而该锁正在被其他线程持有。
为了提高CPU的使用率，当一个线程被阻塞时，另一个线程就获得了运行的机会。当阻塞的原因被消除后，线程将进入就绪状态等待继续执行。
4、Waiting
当线程遇到下面的情况时会进入等待（Waiting）状态，包括：
- 调用
wait方法，等待其他线程通知； - 调用
park方法，等待其他线程调用unpark()释放许可证。
5、Timed Waiting
当线程遇到下面情况时会进入超时等待（Timed Waiting）状态，包括：
- 调用
sleep方法； - 调用带超时时间的
park方法。
6、Terminated
当线程遇到下面的情况时会进入终止（Terminated）状态，包括：
- 线程的run方法执行结束；
- 线程通过某些方法（例如Destory()）被提前终止；
- 在run方法的执行期间发生了未捕获的异常
- 程序的终止操作（如调用System.exit）
二、实例演示
常见的线程转态切换有以下几种：
1、新建 -> 运行 -> 结束
当线程被创建时，进入新建状态；
当线程启动时，进入运行状态；
当run方法体执行结束时，进入终止状态。
代码示例如下：
public class Demo2 {
public static void main(String[] args) throws Exception {
// 第一种状态切换: 新建 -> 运行 -> 终止
System.out.println("####### 第一种状态切换: 新建 -> 运行 -> 终止 #######");
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("thread1当前状态: " + Thread.currentThread().getState().toString());
System.out.println("thread1执行了");
}
});
System.out.println("没调用start方法，thread1当前状态: " + thread1.getState().toString());
thread1.start();
Thread.sleep(2000L); // 主线程休眠两秒，让thread1执行结束后，再看其状态
System.out.println("等待两秒，再看thread1当前状态: " + thread1.getState().toString());
System.out.println();
// thread1.start(); // 注意: 线程终止后，再调用start方法，会抛出IllegalThreadStateException异常
}
}
运行结果：
####### 第一种状态切换: 新建 -> 运行 -> 终止 #######
没调用start方法，thread1当前状态: NEW
thread1当前状态: RUNNABLE
thread1执行了
等待两秒，再看thread1当前状态: TERMINATED
[注意] 当线程结束时，再次启动线程会抛出IllegalThreadStateException异常
2、新建 -> 运行 -> 等待（超时）-> 运行 -> 结束
当线程被创建时，进入新建状态
当线程被启动时，进入运行状态
当调用sleep/park（带超时时间）方法是，进入等待（超时）状态
当线程休眠结束或者拿到许可证时，重新进入运行状态
当run方法体执行结束时，进入终止状态。
代码示例如下：
public class Demo2 {
public static void main(String[] args) throws Exception {
// 第二种状态切换: 新建 -> 运行 -> 等待(超时) -> 运行 -> 终止 (通过线程休眠切换到等待状态)
System.out.println("####### 第二种状态切换: 新建 -> 运行 -> 等待(超时) -> 运行 -> 终止 #######");
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
try { // 将线程移动到等待状态，1500ms后自动唤醒
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread2当前状态: " + Thread.currentThread().getState().toString());
System.out.println("thread2 执行了");
}
});
System.out.println("没调用start方法，thread2当前状态: " + thread2.getState().toString());
thread2.start();
System.out.println("调用start方法，thread2当前状态: " + thread2.getState().toString());
Thread.sleep(200L); // 等待200ms，再看状态
System.out.println("等待200毫秒，再看thread2当前状态: " + thread2.getState().toString());
Thread.sleep(3000L); // 再等待3秒，让thread2执行完毕，再看状态
System.out.println("等待3秒，再看thread2当前状态: " + thread2.getState().toString());
System.out.println();
}
}
运行结果：
####### 第二种状态切换: 新建 -> 运行 -> 等待 -> 运行 -> 终止 #######
没调用start方法，thread2当前状态: NEW
调用start方法，thread2当前状态: RUNNABLE
等待200毫秒，再看thread2当前状态: TIMED_WAITING
thread2当前状态: RUNNABLE
thread2 执行了
等待3秒，再看thread2当前状态: TERMINATED
3、新建 -> 运行 -> 等待（通知/许可）-> 运行 -> 结束
当线程被创建时，进入新建状态
当线程被启动时，进入运行状态
当调用wait/park方法是，进入等待（通知/许可）状态
当线程收到通知或者拿到许可证时，重新进入运行状态
当run方法体执行结束时，进入终止状态。
代码如下：
public class Demo2 {
public static void main(String[] args) throws Exception {
// 第四种状态切换: 新建 -> 运行 -> 等待(通知) -> 运行 -> 终止
System.out.println("####### 第四种状态: 新建 -> 运行 -> 等待(通知) -> 运行 -> 终止 #######");
Thread thread4 = new Thread(new Runnable() {
@Override
public void run() {
try {
synchronized (Demo2.class) {
Demo2.class.wait();
}
System.out.println("thread4收到通知，当前状态: " + Thread.currentThread().getState().toString());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
System.out.println("没调用start方法，thread4当前状态: " + thread4.getState().toString());
thread4.start();
System.out.println("调用start方法，thread4当前状态: " + thread4.getState().toString());
Thread.sleep(200L); // 等待200ms，再看状态
System.out.println("等待200毫秒，再看thread4当前状态: " + thread4.getState().toString());
synchronized (Demo2.class) {
Demo2.class.notifyAll();
}
Thread.sleep(3000L); // 再等待3秒，让thread3执行完毕，再看状态
System.out.println("等待3秒，让thread4执行结束，再看thread4当前状态: " + thread4.getState().toString());
System.out.println();
}
}
运行结果：
####### 第四种状态: 新建 -> 运行 -> 等待 -> 运行 -> 终止 #######
没调用start方法，thread4当前状态: NEW
调用start方法，thread4当前状态: RUNNABLE
等待200毫秒，再看thread4当前状态: WAITING
thread4收到通知，当前状态: RUNNABLE
等待3秒，让thread4执行结束，再看thread4当前状态: TERMINATED
4、新建 -> 运行 -> 阻塞 -> 运行 -> 结束
当线程被创建时，进入新建状态
当线程被启动时，进入运行状态
当线程等待获取锁或其他资源时，进入阻塞状态
当线程拿到了锁或阻塞的资源时，重新进入运行状态
当run方法体执行结束时，进入终止状态。
代码如下：
public class Demo2 {
public static void main(String[] args) throws Exception {
// 第三种状态切换: 新建 -> 运行 -> 阻塞 -> 运行 -> 终止 (通过线程抢锁切换到阻塞状态)
System.out.println("####### 第三种状态切换: 新建 -> 运行 -> 阻塞 -> 运行 -> 终止 #######");
Thread thread3 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (Demo2.class) {
System.out.println("thread3当前状态: " + Thread.currentThread().getState().toString());
System.out.println("thread3 执行了");
}
}
});
synchronized (Demo2.class) {
System.out.println("没调用start方法，thread3当前状态: " + thread3.getState().toString());
thread3.start();
System.out.println("调用start方法，thread3当前状态: " + thread3.getState().toString());
Thread.sleep(200L); // 等待200ms，再看状态
System.out.println("等待200毫秒，再看thread3当前状态: " + thread3.getState().toString());
}
Thread.sleep(3000L); // 再等待3秒，让thread3执行完毕，再看状态
System.out.println("等待3秒，让thread3抢到锁，再看thread3当前状态: " + thread3.getState().toString());
System.out.println();
}
}
结果如下：
####### 第三种状态切换: 新建 -> 运行 -> 阻塞 -> 运行 -> 终止 #######
没调用start方法，thread3当前状态: NEW
调用start方法，thread3当前状态: RUNNABLE
等待200毫秒，再看thread3当前状态: BLOCKED
thread3当前状态: RUNNABLE
thread3 执行了
等待3秒，让thread3抢到锁，再看thread3当前状态: TERMINATED
