线程状态（操作系统层面和Java层面）

1、五种状态（操作系统层面）

• 【初始状态】仅在语言层面创建了线程对象，还未与操作系统线程相关联

• 【可运行状态】指该线程已经被创建完成，可以由cpu调度执行

• 【运行状态】指获取了cpu时间片运行中的状态

  1、当cpu时间片用完后，会从【运行状态】转换为【可运行状态】，会导致线程的上下文切换，进入阻塞状态

• 【阻塞状态】

  1、如果调用了阻塞api，如BIO读取文件，这是线程实际上不会用到cpu，会导致线程上下文切换，进入【阻塞状态】

  2、等BIO操作完毕，会由操作系统唤醒阻塞的线程，转换至可运行状态

  3、和【可运行状态】的区别是，对【阻塞状态】的线程来说只要他们一直不被唤醒，调度器就一直不会考虑调度他们

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

2、六种状态（Java层面）

package com.java_thread.often_methods;

/**
 * 线程状态（Java层面）
 */
public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        //1、NEW
        Thread t1 = new Thread(() -> {
        });
        System.out.println(t1.getState());

        //2、RUNNING （操作系统层面的可运行、运行、阻塞三者合为RUNNING）
        Thread t2 = new Thread(() -> {
            while (true) {

            }
        });
        t2.start();
        System.out.println(t2.getState());

        //3、TERMINATED 已终止
        Thread t3 = new Thread(() -> {
        });
        t3.start();
        Thread.sleep(1000);
        System.out.println(t3.getState());

        //4、TIMED_WAITING 等待终止
        Thread t4 = new Thread(() -> {
            try {
                Thread.sleep(1000*3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t4.start();
        Thread.sleep(1000);
        System.out.println(t4.getState());

        //5、WAITING 等待
        Thread t5 = new Thread(() -> {
            try {
                //等待t2线程完成
                t2.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t5.start();
        Thread.sleep(1000);
        System.out.println(t5.getState());

        //6、BLOCKED 受阻
        //test线程提前拿到锁
        Thread test = new Thread(() -> {
            synchronized (ThreadState.class) {
                try {
                    Thread.sleep(1000*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        test.start();

        Thread t6 = new Thread(() -> {
            synchronized (ThreadState.class) {
                try {
                    Thread.sleep(1000*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t6.start();
        Thread.sleep(1000);
        System.out.println(t6.getState());
    }
}