并发编程(三)：线程状态

线程状态

• 现在线程的状态有五种和六种，五种是以操作系统层面描述的，六种是以Java Thread State枚举描述的

线程五种状态

image.png

1. 【初始状态】仅在语言层面创建了线程，还未与操作系统线程关联
2. 【可运行状态(就绪状态)】该线程已经被创建(与操作系统线程关联)，可以由CPU调度执行
3. 【运行状态】获取了CPU时间片，线程RUN方法代码在执行

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

4. 【阻塞状态】

• 如果调用阻塞API，如BIO读写文件，这时线程实际不会用到CPU，会导致上下文切换，线程进入【阻塞状态】
• 等BIO操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】

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

线程六种状态

• 在Thread类中的enum Stste内部枚举类

  
  image.png

1. NEW 线程刚被创建，但是还没有调用start()方法
2. RUNNABLE 当调用了start()之后，Java API层面的RUNNABLE状态涵盖了操作系统层面的【可运行状态】、【运行状态】、【阻塞状态】(由于BIO导致的线程阻塞，在Java里无法区分，仍然认为是可运行)
3. BLOCKED
4. WAITING
5. TIMED_WAITING
6. TERMINATED 线程执行完毕，生命周期已经结束，不会再装换为其他状态

@Slf4j(topic = "ants.TestThreadState")
public class TestThreadState {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("t1 running");//只是新建对象，这是状态是NEW
            }
        };

        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                while (true){
                    //线程可运行、线程运行以及IO操作都会是RUNNABLE状态
                }
            }
        };
        t2.start();

        Thread t3 = new Thread("t3") {
            @Override
            public void run() {
                log.debug("t3 running");//执行完，线程状态是TERMINATED
            }
        };
        t3.start();

        Thread t4 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (TestThreadState.class){
                    try {
                        Thread.sleep(10000000);//TIMED_WAITING，有时限等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t4.start();

        Thread t5 = new Thread("t5") {
            @Override
            public void run() {
                try {
                    t2.join();//WAITING,t2一致不会结束，无时限等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();

        Thread.sleep(1000);
        Thread t6 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (TestThreadState.class) {
                    log.debug("t6 running");//t6线程和t4线程共用一个锁，t4先拿到锁，这是t6状态是BLOCKED
                }
            }
        };
        t6.start();


        log.debug("t1线程状态:{}",t1.getState());
        log.debug("t2线程状态:{}",t2.getState());
        log.debug("t3线程状态:{}",t3.getState());
        log.debug("t4线程状态:{}",t4.getState());
        log.debug("t5线程状态:{}",t5.getState());
        log.debug("t6线程状态:{}",t6.getState());
    }
}