JAVA线程状态：5种？6种？

一、 java线程状态到底几种？

线程状态网上各种奇葩文章描述5种的也有，7种的也有，这里告诉你：

JDK源码中Thread类内部有枚举类State详细描述了线程6种线程状态：
1.NEW:尚未启动；
2.RUNNABLE：运行中
3.BlOCKED：线程等待monitor锁定的状态（synchronized同步块中阻塞）
4.WAITING:等待线程，主动调用wait()、join()、park()后的状态
5.TIMED_WAITING:等待超时，Thead.sleep(long),wait(long),join(long),parkNanos (long),parkUntil
6.TERMINATED:线程终止

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

二、 java线程状态的切换

线程切换代码示例：

package shen.example.demo.mutithread;

import java.util.concurrent.locks.LockSupport;

/**
 * 线程状态demo
 */
public class ThreadStatusDemo {

    public static void main(String[] args) throws InterruptedException {
        //创建一个线程
        System.out.println("创建子线程new");
        Thread thread = new Thread(()->{
            //2.线程状态：RUNNABLE
            System.out.println(Thread.currentThread().getState());
            System.out.println("子线程运行中...开始调用park()");
            LockSupport.park();
            //睡眠
            try {
                System.out.println("子线程运行中...调用sleep(long)");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //获取同步锁
            System.out.println("子线程运行中...进入同步代码块");
            synchronized (ThreadStatusDemo.class){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //1.线程状态：NEW
        System.out.println(thread.getState());
        System.out.println("子线程启动start");
        //启动线程
        thread.start();
        //主线程睡眠，等待子线程thread调用park()
        Thread.sleep(500);
        //3.线程状态：WAITING
        Thread.sleep(500);
        System.out.println(thread.getState());
        //唤醒子线程,使子线程调用sleep(long)
        LockSupport.unpark(thread);
        //4.TIMED_WAITING
        System.out.println(thread.getState());
        //主线程获取当前类锁
        synchronized (ThreadStatusDemo.class){
            Thread.sleep(1200);//等待子线程进入同步代码块阻塞
            //5.BLOCKED
            System.out.println(thread.getState());
        }
        Thread.sleep(1200);
        System.out.println("子线程运行结束");
        //5.TERMINATED
        System.out.println(thread.getState());
    }
}

运行结果：

创建子线程new
NEW
子线程启动start
RUNNABLE
子线程运行中...开始调用park()
WAITING
子线程运行中...调用sleep(long)
TIMED_WAITING
子线程运行中...进入同步代码块
BLOCKED
子线程运行结束
TERMINATED