技术标签： Java 阻塞 线程状态 blocked waiting

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

    1. /**
    2.  * A thread state.  A thread can be in one of the following states:
    3.  * <ul>
    4.  * <li>{@link #NEW}<br>
    5.  *     A thread that has not yet started is in this state.
    6.  *     </li>
    7.  * <li>{@link #RUNNABLE}<br>
    8.  *     A thread executing in the Java virtual machine is in this state.
    9.  *     </li>
    10.  * <li>{@link #BLOCKED}<br>
    11.  *     A thread that is blocked waiting for a monitor lock
    12.  *     is in this state.
    13.  *     </li>
    14.  * <li>{@link #WAITING}<br>
    15.  *     A thread that is waiting indefinitely for another thread to
    16.  *     perform a particular action is in this state.
    17.  *     </li>
    18.  * <li>{@link #TIMED_WAITING}<br>
    19.  *     A thread that is waiting for another thread to perform an action
    20.  *     for up to a specified waiting time is in this state.
    21.  *     </li>
    22.  * <li>{@link #TERMINATED}<br>
    23.  *     A thread that has exited is in this state.
    24.  *     </li>
    25.  * </ul>
    26.  *
    27.  * <p>
    28.  * A thread can be in only one state at a given point in time.
    29.  * These states are virtual machine states which do not reflect
    30.  * any operating system thread states.
    31.  *
    32.  * @since   1.5
    33.  * @see #getState
    34.  */
    35. public enum State {
    37.     /**
    38.      * Thread state for a thread which has not yet started.
    39.      */
    40.     NEW,
    42.     /**
    43.      * Thread state for a runnable thread.  A thread in the runnable
    44.      * state is executing in the Java virtual machine but it may
    45.      * be waiting for other resources from the operating system
    46.      * such as processor.
    47.      */
    48.     RUNNABLE,
    50.     /**
    51.      * Thread state for a thread blocked waiting for a monitor lock.
    52.      * A thread in the blocked state is waiting for a monitor lock
    53.      * to enter a synchronized block/method or
    54.      * reenter a synchronized block/method after calling
    55.      * {@link Object#wait() Object.wait}.
    56.      */
    57.     BLOCKED,
    59.     /**
    60.      * Thread state for a waiting thread.
    61.      * A thread is in the waiting state due to calling one of the
    62.      * following methods:
    63.      * <ul>
    64.      *   <li>{@link Object#wait() Object.wait} with no timeout</li>
    65.      *   <li>{@link #join() Thread.join} with no timeout</li>
    66.      *   <li>{@link LockSupport#park() LockSupport.park}</li>
    67.      * </ul>
    68.      *
    69.      * <p>A thread in the waiting state is waiting for another thread to
    70.      * perform a particular action.
    71.      *
    72.      * For example, a thread that has called <tt>Object.wait()</tt>
    73.      * on an object is waiting for another thread to call
    74.      * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
    75.      * that object. A thread that has called <tt>Thread.join()</tt>
    76.      * is waiting for a specified thread to terminate.
    77.      */
    78.     WAITING,
    80.     /**
    81.      * Thread state for a waiting thread with a specified waiting time.
    82.      * A thread is in the timed waiting state due to calling one of
    83.      * the following methods with a specified positive waiting time:
    84.      * <ul>
    85.      *   <li>{@link #sleep Thread.sleep}</li>
    86.      *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
    87.      *   <li>{@link #join(long) Thread.join} with timeout</li>
    88.      *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
    89.      *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
    90.      * </ul>
    91.      */
    92.     TIMED_WAITING,
    94.     /**
    95.      * Thread state for a terminated thread.
    96.      * The thread has completed execution.
    97.      */
    98.     TERMINATED;
    99. }

    注释已经写的很清楚了。

    重点来看 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 状态需要进行系统调用，所以到这个状态的转换操作比较重。

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

    版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
    本文链接：https://blog.csdn.net/L__ear/article/details/106475862