java Thread种的6种状态。总结整理

线程的状态应该是面试中很常问道的知识点。前两天自己在答的时候都是按照操作系统的5种状态来答的。后来，然后有哪些操作会导致进入哪几种状态自己答得也不是很好。所以回来整理一下。

1. java线程中到底有几种状态。

查看源码(在java.lang.Thread中)可以发现java中的线程状态共有6种而不是像操作系统中的5状态图。

    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.
         * 可运行状态的线程是在jvm中正在执行的线程状态。但该线程
         * 可能正在等待操作系统资源（如处理器）
         */
        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}.
         * 阻塞状态的线程等待一个监视器锁以进入一个同步代码块/同步方法，
         * 或者该线程在调用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>
         * 当线程调用Object.wait()方法，Thread.join()方法和
         * LockSupport.park()方法是会造成线程等待
         *
         * <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.
         * 例如，一个线程调用wait方法后，需要别的线程调用notify方法将其唤醒；
         * 一个线程调用Thread.join()方法后需等待特定线程终止。
         */
        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>
         * 当调用Thread.sleep、Object.wait(long timeout)、Thread.join(long timeout)
         * LockSupport.parkNanos、LockSupport.parkUntil这些方法时，
         * 会造成线程进入timed waiting状态
         */
        TIMED_WAITING,

        /**
         * 终止状态的线程
         * Thread state for a terminated thread.
         * The thread has completed execution.
         * 终止状态的线程意味着线程已经执行结束。
         */
        TERMINATED;
    }

Thead类内部有一个枚举类State，列举了线程中可能存在的6种状态为：

1. New 新建状态：新建的Thread对象，未调用start()
2. Runnable 可运行状态：可运行状态中包含

• 就绪态：已经获取所有资源，CPU分配执行权就可以执行，所有就绪态线程都在就绪队列中
• 运行态：正在执行的线程，一个CPU同一时间只能处理一个线程，因此一个CPU上只有一个运行态程序

3. Blocked 阻塞状态：线程请求资源失败时会进入该状态。所有阻塞态线程都存储在一个阻塞队列中，阻塞态线程会不断请求资源成功后进入就绪队列。等待执行。
4. Waiting 等待状态：wait、join等函数会造成进入该状态。同样有一个等待队列存储所有等待线程，线程会等待其他线程指示才能继续执行。等待状态线程主动放弃CPU执行权
5. Timed_Waiting 计时等待：计时等待也是主动放弃CPU执行权的，区别是，超时后会进入阻塞态竞争资源
6. Terminal 结束状态：线程执行结束后的状态。

2. 线程的状态转换