并发编程(五)-线程状态分析

一、线程状态

1. 操作系统层面的5种线程状态

（1） 【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联(还未start)。

（2） 【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行。

（3） 【运行状态】指获取了 CPU 时间片运行中的状态。

• 当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换。

（4） 【阻塞状态】

• 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】，等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】。
• 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们。

（5） 【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态。

2. Java API 层面的6种线程状态

• 根据 Thread.State 枚举，分为六种状态
  
• 【NEW】线程刚被创建，但是还没有调用 start() 方法
• 【RUNNABLE】 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了 操作系统 层面的【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行）
• 【BLOCKED】 、【WAITING】 、【TIMED_WAITING 】都是 Java API 层面对【阻塞状态】的细分
• 【TERMINATED】 当前线程代码运行结束

（1）演示 IO 操作时的线程状态

• 文件读取操作，在操作系统层面是【阻塞状态】
• 但是在 Java API 层面是 【RUNNABLE】

（2）演示6种线程状态

@Slf4j(topic = "c.TestState1")
public class TestState1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {

        }, "t1");

        Thread t2 = new Thread(() -> {
            while (true) {

            }
        }, "t2");
        t2.start();

        Thread t3 = new Thread(() -> {
            log.info("t3执行完就结束");
        }, "t3");
        t3.start();

        Thread t4 = new Thread(() -> {
            synchronized (TestState1.class) {
                try {
                    Thread.sleep(100000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t4");
        t4.start();

        Thread t5 = new Thread("t5"){
            @Override
            public void run() {
                try {
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();

        Thread t6 = new Thread(() -> {
            synchronized (TestState1.class) {

            }
        }, "t6");
        t6.start();

        log.info("t1还没start时的状态：{}", t1.getState());
        log.info("t2 start后空循环时的状态：{}", t2.getState());
        log.info("t3执行完就结束的状态：{}", t3.getState());
        log.info("t4拿着锁休眠时的状态：{}", t4.getState());
        log.info("t2一直空循环，t5等待t2时的状态：{}", t5.getState());
        log.info("t6与t4抢同一把锁时的状态：{}", t6.getState());
    }
}

15:54:12.641 c.TestState1 [t3] - t3执行完就结束
15:54:12.641 c.TestState1 [main] - t1还没start时的状态：NEW
15:54:12.645 c.TestState1 [main] - t2 start后空循环时的状态：RUNNABLE
15:54:12.645 c.TestState1 [main] - t3执行完就结束的状态：TERMINATED
15:54:12.645 c.TestState1 [main] - t4拿着锁休眠时的状态：TIMED_WAITING
15:54:12.646 c.TestState1 [main] - t2一直空循环，t5等待t2时的状态：WAITING
15:54:12.646 c.TestState1 [main] - t6与t4抢同一把锁时的状态：BLOCKED

3. 线程状态转换

情况 1 NEW --> RUNNABLE

• 当调用 t.start() 方法时，由 NEW --> RUNNABLE

情况 2 RUNNABLE <–> WAITING

• t 线程用 synchronized(obj) 获取了对象锁后
  • 调用 obj.wait() 方法时，t 线程从 RUNNABLE --> WAITING
  • 调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
    • 竞争锁成功，t 线程从 WAITING --> RUNNABLE
    • 竞争锁失败，t 线程从 WAITING --> BLOCKED

情况 3 RUNNABLE <–> WAITING

• 例如：当前线程时main线程
• 当前线程调用 t.join() 方法时，当前线程从 RUNNABLE --> WAITING
  • 注意是当前线程在t 线程对象的监视器上等待
• t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从 WAITING --> RUNNABLE

情况 4 RUNNABLE <–> WAITING

• 当前线程调用 LockSupport.park() 方法会让当前线程从 RUNNABLE --> WAITING
• 调用 LockSupport.unpark(目标线程) 或调用了目标线程 的 interrupt() ，会让目标线程从 WAITING -->RUNNABLE

情况 5 RUNNABLE <–> TIMED_WAITING

• t 线程用 synchronized(obj) 获取了对象锁后
• 调用 obj.wait(long n) 方法时，t 线程从 RUNNABLE --> TIMED_WAITING
• t 线程等待时间超过了 n 毫秒，或调用 obj.notify() ， obj.notifyAll() ， t.interrupt() 时
  • 竞争锁成功，t 线程从 TIMED_WAITING --> RUNNABLE
  • 竞争锁失败，t 线程从 TIMED_WAITING --> BLOCKED

情况 6 RUNNABLE <–> TIMED_WAITING

• 当前线程调用 t.join(long n) 方法时，当前线程从 RUNNABLE --> TIMED_WAITING
  • 注意是当前线程在t 线程对象的监视器上等待
• 当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从TIMED_WAITING --> RUNNABLE

情况 7 RUNNABLE <–> TIMED_WAITING

• 当前线程调用 Thread.sleep(long n) ，当前线程从 RUNNABLE --> TIMED_WAITING
• 当前线程等待时间超过了 n 毫秒，当前线程从 TIMED_WAITING --> RUNNABLE

情况 8 RUNNABLE <–> TIMED_WAITING

• 当前线程调用 LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long millis) 时，当前线程从 RUNNABLE --> TIMED_WAITING
• 调用 LockSupport.unpark(目标线程) 或调用了目标线程 的 interrupt() ，或是等待超时，会让目标线程从TIMED_WAITING–> RUNNABLE

情况 9 RUNNABLE <–> BLOCKED

• t 线程用 synchronized(obj) 获取了对象锁时如果竞争失败，从 RUNNABLE --> BLOCKED
• 持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED 的线程重新竞争，如果其中 t 线程竞争成功，从 BLOCKED --> RUNNABLE ，其它失败的线程仍然 BLOCKED

情况 10 RUNNABLE <–> TERMINATED

• 当前线程所有代码运行完毕，进入TERMINATED