一、引子
synchronized 会阻塞线程，AQS 也会阻塞线程。那么这两种情况，阻塞后，线程的状态是什么，是 waiting 还是 blocked。虽然好像知道，但不能确定。在网上搜索后，经过指引，找到 Thread.State 这个内部枚举类型。
/**
* A thread state. A thread can be in one of the following states:
* <ul>
* <li>{@link #NEW}<br>
* A thread that has not yet started is in this state.
* </li>
* <li>{@link #RUNNABLE}<br>
* A thread executing in the Java virtual machine is in this state.
* </li>
* <li>{@link #BLOCKED}<br>
* A thread that is blocked waiting for a monitor lock
* is in this state.
* </li>
* <li>{@link #WAITING}<br>
* A thread that is waiting indefinitely for another thread to
* perform a particular action is in this state.
* </li>
* <li>{@link #TIMED_WAITING}<br>
* A thread that is waiting for another thread to perform an action
* for up to a specified waiting time is in this state.
* </li>
* <li>{@link #TERMINATED}<br>
* A thread that has exited is in this state.
* </li>
* </ul>
*
* <p>
* 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:
* <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;
}
注释已经写的很清楚了。
重点来看 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 状态需要进行系统调用，所以到这个状态的转换操作比较重。
至于系统调用为什么比较重，可以参考 为什么系统调用比普通的函数调用更耗时？用户态和内核态切换的代价在哪？