线程状态

线程在执行过程中，状态并不是一层不变的。

线程的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