Java 线程状态之 blocked 和 waiting 的区别

一、引子

synchronized 会阻塞线程，AQS 也会阻塞线程。那么这两种情况，阻塞后，线程的状态是什么，是 waiting 还是 blocked。虽然好像知道，但不能确定。在网上搜索后，经过指引，找到 Thread.State 这个内部枚举类型。

    /**
     * A thread state.  A thread can be in one of the following states:
     * 

     * 
{@link #NEW}

     *     A thread that has not yet started is in this state.
     *     
     * 
{@link #RUNNABLE}

     *     A thread executing in the Java virtual machine is in this state.
     *     
     * 
{@link #BLOCKED}

     *     A thread that is blocked waiting for a monitor lock
     *     is in this state.
     *     
     * 
{@link #WAITING}

     *     A thread that is waiting indefinitely for another thread to
     *     perform a particular action is in this state.
     *     
     * 
{@link #TIMED_WAITING}

     *     A thread that is waiting for another thread to perform an action
     *     for up to a specified waiting time is in this state.
     *     
     * 
{@link #TERMINATED}

     *     A thread that has exited is in this state.
     *     
     * 
     *
     * 

     * A thread can be in only one state at a given point in time.
     * These states are virtual machine states which do not reflect
     * any operating system thread states.
     *
     * @since   1.5
     * @see #getState
     */
    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:
         * 

         *   
{@link Object#wait() Object.wait} with no timeout
         *   
{@link #join() Thread.join} with no timeout
         *   
{@link LockSupport#park() LockSupport.park}
         * 
         *
         * 
A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called Object.wait()
         * on an object is waiting for another thread to call
         * Object.notify() or Object.notifyAll() on
         * that object. A thread that has called Thread.join()
         * 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:
         * 

         *   
{@link #sleep Thread.sleep}
         *   
{@link Object#wait(long) Object.wait} with timeout
         *   
{@link #join(long) Thread.join} with timeout
         *   
{@link LockSupport#parkNanos LockSupport.parkNanos}
         *   
{@link LockSupport#parkUntil LockSupport.parkUntil}
         * 
         */
        TIMED_WAITING,

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

注释已经写的很清楚了。

重点来看 WAITING 和 BLOCKED 这两种状态。

二、BLOCKED

A thread that is blocked waiting for a monitor lock is in this state.

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 Object#wait() Object.wait.

这样看来，blocked 状态仅与 synchronized 关键字引起线程阻塞有关。

三、WAITING

A thread that is waiting indefinitely for another thread to perform a particular action is in this state.

Thread state for a waiting thread. A thread is in the waiting state due to calling one of the following methods:

• Object#wait() Object.wait with no timeout
• #join() Thread.join with no timeout
• LockSupport#park() LockSupport.park

A thread in the waiting state is waiting for another thread to perform a particular action.

For example, a thread that has called Object.wait() on an object is waiting for another thread to call Object.notify() or Object.notifyAll() on that object. A thread that has called Thread.join() is waiting for a specified thread to terminate.

我们知道，AQS 内部就是依赖 LockSupport.park 阻塞线程，所以在 AQS 中被阻塞的线程处于 waiting 状态。

四、总结

blocked 和 waiting 是 Java 线程的两种阻塞状态。
因为争用 synchronized 的 monitor 对象而发生阻塞的线程处于 blocked 状态。
而 AQS 中的阻塞线程处于 waiting 状态。

两种状态的区别：
两种状态对应的场景的区别，源码中的注释已经讲的很清楚了。

但既然都是阻塞，还要分成这两种，除了场景不同外，肯定还有底层更深层次的原因。
个人认为更加本质的区别是，blocked 状态指的是进行系统调用，通过操作系统挂起线程后，线程的状态。而 waiting 状态则不需要进行系统调用，是一种 JVM 层面的线程阻塞后的状态。由于转换到 blocked 状态需要进行系统调用，所以到这个状态的转换操作比较重。

至于系统调用为什么比较重，可以参考 为什么系统调用比普通的函数调用更耗时？用户态和内核态切换的代价在哪？