JAVA线程状态详解

Java中线程状态源码

java包位置：java.lang.Thread.State（Thread的内部枚举类）

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中线程状态(六种)

1.NEW

新建状态，表示一个Thread刚刚被创建出来，还没有启动

2.RUNNABLE

运行状态，表示线程处于JVM层面的运行态。一个新创建好的线程，调用其start()方法后，就会由NEW状态迁移到RUNNABLE状态。需要注意的是：这里的RUNNABLE是相对于JVM的状态来说的，而线程具体何时运行，取决于操作系统底层的资源调度。

3.BLOCKED

阻塞状态，表示线程正在等待一个监视器锁(monitor lock)，而监视器锁在Java代码中的体现就是synchronized关键字。也就是说：只有线程在等待进入synchronized修饰的代码块或方法时，线程才处于BLOCKED状态。

4.WAITING

处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。

等待状态，表示线程在等待某些条件的到达。在调用以下方法后，线程会进入WAITING状态：
Object中定义的无超时的wait()方法，等待一个同步监视器的唤醒；
Thread中定义的无超时的join()方法，等待其他线程执行完毕；
LockSupport.park()方法。

5.TIMED_WAITING

处于这种状态的线程不会被分配CPU执行时间，不会无线等待，在达到一定时间后它们会自动唤醒。

超时等待状态，与WAITING状态类似，并在其基础上，增加了超时的限制。在调用以下方法后，线程会进入TIMED_WAITING状态：
Thread.sleep()方法，线程定时休眠；
Object中定义的带超时的wait()方法；
Thread中定义的带超时的join()方法；
LockSupport.parkNanos()方法；
LockSupport.parkUntil()方法。

6.TERMINATED

终止状态，包括线程正常执行完毕和异常终止。

Linux系统的线程状态(这块内容过于复杂仅供参考)

先简单谈谈CPU的调度(仅供参考，因为没对操作系统进行细致的研究)

1. 如果线程完全在内核态中实现（内核线程，KLT），内核调度的单元是线程。此时，进程与线程的区别非常微妙。
2. 如果线程完全在用户态实现（用户线程，ULT），内核调度的单元是进程，内核对用户线程一无所知。内核只负责分配CPU给进程，进程得到CPU会后再分配给内部的线程

进程的状态

运行态（此进程实际占用CPU）

就绪态（可运行，但因其他进程正在运行而暂时停止）

阻塞态（除非某种外部事件发生，否则进程不能运行）

操作系统线程状态与JVM线程状态区别

上面介绍了操作系统线程状态其实就想说明一下一些问题：

1. JAVA中的六种线程状态是相对于JVM而言的，与操作系统无关。之所以定义这些状态是为了从JVM层面来管理线程
2. 说一下JAVA线程的RUNNABLE状态，从字面意思来讲是“可运行的”，但实际上，假如线程处于RUNNABLE状态，对应的线程是否被CPU调度，JVM是不知道的，不关心的，不透明的。即从CPU来讲该线程可能是“阻塞态”、“运行态”、“就绪态”，这里的状态并非JVM状态。

JAVA线程状态与占用CPU关系

1. 仅有线程状态为RUNNABLE时，才可能占用CPU，这里是可能，但其实从JVM层面来讲，RUNNABLE就是在占用CPU资源，从操作系统层面来讲，RUNNABLE可能再占用CPU资源，这可能很矛盾，但这是每个层面的视角不同而已。
2. 非RUNNABLE状态，一定不占用CPU资源

JAVA线程相关方法与线程状态、锁的关系

Thread.sleep(long millis)方法

方法作用： 延时、阻塞
线程状态： TIMED_WAITING
锁特点： 不释放锁
代码块： 阻塞代码块

Thread.yield()方法

方法作用： 通知操作系统底层，放弃当前的CPU时间片，yield也可以理解为线程让步,但并非绝对让步，依然需要根据线程调度优先级来决定。个人感觉，这个方法的使用场景更像是在一些当前线程高度占用CPU时，均衡一些次要线程的调度。
线程状态： RUNNABLE
锁特点： 不释放锁
代码块： 不阻塞

obj.wait()/obj.wait(long millis)方法

方法作用： 使线程等待，依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout时间到自动唤醒。
线程状态： WAITING/TIMED_WAITING
锁特点： 释放锁
代码块： 阻塞.

thread.join()/thread.join(long millis)方法

方法作用： 线程A执行了thread.join()语句，其含义是：当前线程A等待thread线程终止之后才从thread.join()返回
线程状态： WAITING/TIMED_WAITING
锁特点： 不释放锁
代码块： 阻塞

obj.notify()方法

方法作用： 唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。
线程状态： RUNNABLE
锁特点： 不释放锁
代码块： 不阻塞

LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkUntil(long deadlines)方法

方法作用： 不需要获得锁就可以让线程进入WAITING/TIMED_WAITING状态，LockSupport.unpark(Thread thread)唤醒
线程状态： WAITING/TIMED_WAITING
锁特点： 不需要获得锁就可以让线程进入等待态
代码块： 不阻塞

参考文献：Java线程的6种状态及切换(透彻讲解)