作者:( •̀ ω •́ )y

出处:https://www.cnblogs.com/laishenghao/p/13972421.html

一、线程状态的枚举

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

1、NEW：初始状态。

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

// 实例创建后，初始状态为 NEWThread 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。

作者:( •̀ ω •́ )y

出处:https://www.cnblogs.com/laishenghao/p/13972421.html