【Java】线程的 6 种状态

一、线程状态的枚举

Java的线程从创建到销毁总共有6种状态。这些状态被定义在Thread类种的内部枚举 State 中，分别如下：

1、NEW：初始状态。

线程实例已创建，但未启动。

// 实例创建后，初始状态为 NEW
Thread thread = new Thread();

2、RUNNABLE：运行状态。

线程正在JVM中执行或等待操作系统资源（如CPU），包含 Ready（就绪）状态和 Running（运行中）状态。

（1）Ready 状态：该线程在可运行的状态，但在此刻线程调度器并没有选择执行该线程。

（2）Running 状态：此刻线程调度器选择执行该线程，线程得到了CPU的时间片资源。

3、BLOCKED：阻塞状态。

线程在等待获取监视器锁资源，以便进入 synchronized 标记的方法或者代码块。

4、WAITING：等待状态。

当调用以下方法后，线程将进入等待状态：

（1）Object.wait(); // 调用不带超时参数的 wait() 方法。

（2）anotherThread.join(); // 调用另一个线程的不带超时参数的 join() 方法。

（3）LockSupport.park(); // 无限期挂起当前线程。

5、TIMED_WAITING：超时等待状态。

指定了超时时间的等待状态。当线程调用了如下方法后，线程将进入超时等待状态：

（1）Thread.sleep(long millis) 或 Thread.sleep(long millis, int nanos)

（2）Object.wait(long timeout) 或 Object.wait(long timeout, int nanos)

（3）anotherThread.join(long millis) 或 anotherThread.join(long millis, int nanos)

（4）LockSupport.parkNanos(Object blocker, long nanos) 或 LockSupport.parkUntil(Object blocker, long deadline)

可以看到，跟 WAITING 状态相比，引起 TIMED_WAITING 状态的方法，主要是多了超时参数。

6、TERMINATED：终止状态。

线程执行完成或被中断，将进入终止状态。进入终止状态后的线程，无法重启启动。

如果再次调用 start() 方法，将会抛出 IllegalThreadStateException 异常。

调用run() 方法也不会有任何效果，线程内部的 Runnable 对象也已经被释放。

二、线程状态的转换

Java线程状态的转换过程，如下图所示。

三、线程状态的获取

当前线程的状态可以通过 Thread.currentThread().getState() 获取。显然，获取自己的状态，得到的肯定是运行状态。

一个线程实例的状态，可以通过 thread.getState()方法获取。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            // running:RUNNABLE
            System.out.println("running:" + Thread.currentThread().getState());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // before start():NEW
        System.out.println("before start():" + thread.getState());
        thread.start();
        // 暂停一下主线程
        Thread.sleep(100);
        // 由于线程内sleep了1秒，此时将处于有限时间等待状态
        // after start():TIMED_WAITING
        System.out.println("after start():" + thread.getState());
        // 等待线程结束
        thread.join();
        // thread state:TERMINATED
        System.out.println("thread state:" + thread.getState());
    }
}

测试Lock对应的线程状态：

public class Main {
    private static final Lock LOCK = new ReentrantLock();
    private static volatile int value = 0;
​
    public static void main(String[] args) throws InterruptedException {
        Thread alice = new Thread(() -> testLock("Alice"));
        Thread bob = new Thread(() -> testLock("Bob"));
        // alice before start():NEW
        System.out.println("alice before start():" + alice.getState());
        alice.start();
        // 暂停一下主线程
        Thread.sleep(100);
        bob.start();
        Thread.sleep(100);
        // bob.getState():WAITING
        System.out.println("bob.getState():" + bob.getState());
        value = 1000;
    }
​
    static void testLock(String name) {
        // 注意：锁住的是代码块，不是里面用到的变量、资源
        LOCK.lock();
        try {
            System.out.println("Lock block code, name=" + name);
            // 注意：这是非线程安全的操作
            value += 10;
            System.out.println("Before sleep(): name=" + name + ",value=" + value);
            Thread.sleep(1000);
            System.out.println("After sleep(): name=" + name + ",value=" + value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            LOCK.unlock();
        }
    }
}

由上面的例子可见，等待进入Lock.lock() 代码块的线程的状态，是 WAITING 状态，而不是 BLOCKED。

如果调用的是Lock.tryLock(long, TimeUnit) 方法，对应的状态将是 TIMED_WAITING。