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