并发编程:java中线程的六种状态

1:java线程中的六种状态

学过计算机操作系统的都了解过线程由五种状态组成,分别为: 新建，就绪，运行，阻塞，死亡这五种状态。但java中线程的状态却有六种组成.通过Thread.java源码来看.

线程的状态分别为: NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED;

1:初始(NEW): 新建一个线程对象，但还没有调用start()方法.

2:  运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”,此时有可能分配了时间片,也有可能没有分配时间片. 

代码解释:创建对象后,并且start启动了线程,线程用了while死循环,一直在占用cpu,所以此时是RUNNABLE状态

3. 终止(TERMINATED)：表示该线程已经执行完毕。

代码解释:创建对象后,并且start启动了线程,但是代码瞬间执行完毕,cpu用完就释放了,所以是TERMINATED状态

 4. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。

代码解释: 此线程调用了sleep方法将该线程暂时睡眠,所以又成为有时间的等待,时间一过就会恢复,所以是TIMED_WAITING 状态

5. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。

代码解释: 该线程调用了 thread2线程的join方法,但是线程2是死循环,一直不会停止,所以该线程需要等线程2执行完毕才能继续执行, 又称为需要等待其他线程做出改变的动作,所以是WAITING 状态

6. 阻塞(BLOCKED)：表示线程阻塞于锁。两个线程抢占同一个锁,没抢到锁的线程就会进行BLOCKED状态.

代码解释:线程6和线程4有一个共同的特点就是给ThreadState.class进行了加锁,线程4的执行时间比较长,锁被线程4掌握, 这个时候线程6就会拿不到锁也就进人了BLOCKED状态

2:如何用代码来实现这六种状态

package com.thread.demo.test;

/**
 * @author WHJ
 * @date 2022/3/1 14:27
 */
public class ThreadState {
    public static void main(String[] args) {
        //1: 新建一个对象,没有start 所以此时是NEW状态
        Thread thread1 = new Thread("t1") {
            @Override
            public void run() {
                System.out.println("running....");
            }
        };
        //2: 创建对象后,并且start启动了线程,线程用了while死循环,一直在占用cpu,所以此时是RUNNABLE状态
        Thread thread2 = new Thread("t2") {
            @Override
            public void run() {
                while (true) {

                }
            }
        };
        thread2.start();
        //3:创建对象后,并且start启动了线程,但是代码瞬间执行完毕,cpu用完就释放了,所以是TERMINATED状态
        Thread thread3 = new Thread("t3") {
            @Override
            public void run() {
                System.out.println("running....");
            }
        };
        thread3.start();
        //4:此线程调用了sleep方法将该线程暂时睡眠,所以又成为有时间的等待,时间一过就会恢复,所以是TIMED_WAITING 状态
        Thread thread4 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (ThreadState.class) {
                    try {
                        Thread.sleep(99999);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        thread4.start();
        /**
         *  5:该线程调用了 thread2线程的join方法,但是线程2是死循环,一直不会停止,所以该线程需要等线程2执行完毕才能继续执行,
         *    又称为需要等待其他线程做出改变的动作,所以是WAITING 状态
         */
        Thread thread5 = new Thread("t5") {
            @Override
            public void run() {
                try {
                    thread2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        thread5.start();
        /**
         * 6:线程6和线程4有一个共同的特点就是给ThreadState.class进行了加锁,线程4的执行时间比较长,锁被线程4掌握,
         *  这个时候线程6就会拿不到锁也就进人了BLOCKED状态
         */
        Thread thread6 = new Thread("t6") {
            @Override
            public void run() {
                synchronized (ThreadState.class) {
                    try {
                        Thread.sleep(999999);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        thread6.start();

        System.out.println("thread1的状态是: "+thread1.getState());
        System.out.println("thread2的状态是: "+thread2.getState());
        System.out.println("thread3的状态是: "+thread3.getState());
        System.out.println("thread4的状态是: "+thread4.getState());
        System.out.println("thread5的状态是: "+thread5.getState());
        System.out.println("thread6的状态是: "+thread6.getState());
    }

}

代码的执行结果如下: