State

  • volatile修饰
  • 同步状态
  1. //同步状态
  2. private volatile int state;
  4. /**
  5.  * Returns the current value of synchronization state.
  6.  * This operation has memory semantics of a {@code volatile} read.
  7.  * @return current state value
  8.  */
  9. protected final int getState() {
  10.     return state;
  11. }
  13. /**
  14.  * Sets the value of synchronization state.
  15.  * This operation has memory semantics of a {@code volatile} write.
  16.  * @param newState the new state value
  17.  */
  18. protected final void setState(int newState) {
  19.     state = newState;
  20. }
  22. /**
  23.  * Atomically sets synchronization state to the given updated
  24.  * value if the current state value equals the expected value.
  25.  * This operation has memory semantics of a {@code volatile} read
  26.  * and write.
  27.  *
  28.  * @param expect the expected value
  29.  * @param update the new value
  30.  * @return {@code true} if successful. False return indicates that the actual
  31.  *         value was not equal to the expected value.
  32.  */
  33. protected final boolean compareAndSetState(int expect, int update) {
  34.     // See below for intrinsics setup to support this
  35.     return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
  36. }

Node

SHARED && EXCLUSIVE

  • 独占队列和共享队列是根据SHARED和EXCLUSIVE两个静态变量区分的

waitStatus

  • 0，默认初始值
  • CANCELLED，此节点由于超时或者中断被取消了，该状态不可以再次被修改为其他状态
  • SIGNAL
    • 表明后继节点在阻塞队列中，需要被唤醒，当前节点释放后（release）应该将后继节点从等待队列中移除（unpark）
  • CONDITION，表明此节点处于条件等待状态（条件等待队列中），在调用Condition的await相关方法后会进入条件队列，并等待其他线程唤醒。
  • PROPAGATE，传播

image.png

prev

  • 前驱节点

next

  • 后继节点

thread

  • 等待队列中的线程，对应当前节点

nextWaiter

  • 下一个等待节点，用于条件队列中

head

  • 头结点
  • 只有成功获取状态的节点才能成为头结点


tail

  • 尾结点


spinForTimeoutThreshold

  1. //设定的自旋时间
  2. static final long spinForTimeoutThreshold = 1000L;
  4. //在相关的抢夺锁过程中会有对超时时间的判断
  5. if (shouldParkAfterFailedAcquire(p, node) &&
  6.      nanosTimeout > spinForTimeoutThreshold)
  7.      LockSupport.parkNanos(this, nanosTimeout);

ConditionObject

  • 条件控制器，Condition接口实现类
  1. /**
  2.  * Condition
  3.  */
  4. public interface Condition {
  6.     /**
  7.      * 挂起
  8.      */
  9.     void await() throws InterruptedException;
  11.     void awaitUninterruptibly();
  13.     long awaitNanos(long nanosTimeout) throws InterruptedException;
  15.     boolean await(long time, TimeUnit unit) throws InterruptedException;
  17.     boolean awaitUntil(Date deadline) throws InterruptedException;
  20.     /**
  21.      * 唤醒
  22.      */
  23.     void signal();
  25.     void signalAll();
  27. }
  30. /**
  31.  * ConditionObject
  32.  */
  33. public class ConditionObject implements Condition, java.io.Serializable {
  34.     private static final long serialVersionUID = 1173984872572414699L;
  35.     /** First node of condition queue. */
  36.     private transient Node firstWaiter;
  37.     /** Last node of condition queue. */
  38.     private transient Node lastWaiter;
  40.     /**
  41.      * Creates a new {@code ConditionObject} instance.
  42.      */
  43.     public ConditionObject() { }
  45.     ....
  46. }

一般通过Sync对象去构造一个ConditionObject对象，用于Condition的相关操作

  1. public Condition newCondition() {
  2.     return sync.newCondition();
  3. }