Condition

在 Object 模型上，一个对象拥有一个同步队列和一个等待队列，而并发包中的 Lock（更确切地说是同步器）拥有一个同步队列和多个等待队列。

调用方法 tryAcquire 尝试获取锁，获取失败后，会先自旋几次，在执行 park：

  1. public final void acquire(int arg) {
  2.     // 先尝试获取一次锁
  3.     if (!tryAcquire(arg) &&
  4.         acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
  5.         selfInterrupt();
  6. }
  8. // 将当前节点添加到同步队列的末尾
  9. private Node addWaiter(Node mode) {
  10.     // 保存了当前线程和模式 Node，排他为 null，共享为 new Node()
  11.     Node node = new Node(Thread.currentThread(), mode);
  12.     // Try the fast path of enq; backup to full enq on failure
  13.     Node pred = tail;
  14.     if (pred != null) {
  15.         node.prev = pred;
  16.         if (compareAndSetTail(pred, node)) {
  17.             pred.next = node;
  18.             return node;
  19.         }
  20.     }
  21.     // 如果没有前置节点，就创建一个新的节点作为前置节点
  22.     enq(node);
  23.     return node;
  24. }
  26. final boolean acquireQueued(final Node node, int arg) {
  27.     boolean failed = true;
  28.     try {
  29.         boolean interrupted = false;
  30.         for (;;) {
  31.             // 获得前置节点
  32.             final Node p = node.predecessor();
  33.             // 如果前置节点为头节点，并且成功获取锁
  34.             if (p == head && tryAcquire(arg)) {
  35.                 // 获取锁后，将头结点设为自己
  36.                 setHead(node);
  37.                 p.next = null; // help GC
  38.                 failed = false;
  39.                 return interrupted;
  40.             }
  41.             // 判断是否要挂起线程，短路与后，执行 park，并检查中断状态
  42.             // 如果有其他线程释 unpark 了当前线程，或者中断了当前线程
  43.             // 当前线程就会退出 park，重新进入循环尝试获取锁
  44.             if (shouldParkAfterFailedAcquire(p, node) &&
  45.                 parkAndCheckInterrupt())
  46.                 interrupted = true;
  47.         }
  48.     } finally {
  49.         if (failed)
  50.             cancelAcquire(node);
  51.     }
  52. }
  54. private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
  55.     int ws = pred.waitStatus;
  56.     if (ws == Node.SIGNAL)
  57.         /*
  58.          * This node has already set status asking a release
  59.          * to signal it, so it can safely park.
  60.          */
  61.         // 当前节点已经准备等待一个 release 信号来通知它，所以可以安全的挂起
  62.         return true;
  63.     if (ws > 0) {
  64.         /*
  65.          * Predecessor was cancelled. Skip over predecessors and
  66.          * indicate retry.
  67.          */
  68.         // 前置节点被取消，
  69.         do {
  70.             node.prev = pred = pred.prev;
  71.         } while (pred.waitStatus > 0);
  72.         pred.next = node;
  73.     } else {
  74.         /*
  75.          * waitStatus must be 0 or PROPAGATE.  Indicate that we
  76.          * need a signal, but don't park yet.  Caller will need to
  77.          * retry to make sure it cannot acquire before parking.
  78.          */
  79.         // 指示说，我们需要一个信号，但不挂起。
  80.         // 调用者需要重新获取锁，来保证在挂起前确实获取不到锁
  81.         compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
  82.     }
  83.     return false;
  84. }
  1. public final boolean release(int arg) {
  2.     if (tryRelease(arg)) {
  3.         Node h = head;
  4.         if (h != null && h.waitStatus != 0)
  5.             // 唤醒下一个节点
  6.             unparkSuccessor(h);
  7.         return true;
  8.     }
  9.     return false;
  10. }
  12. /**
  13.  * Wakes up node's successor, if one exists.
  14.  *
  15.  * @param node the node
  16.  */
  17. private void unparkSuccessor(Node node) {
  18.     /*
  19.      * If status is negative (i.e., possibly needing signal) try
  20.      * to clear in anticipation of signalling.  It is OK if this
  21.      * fails or if status is changed by waiting thread.
  22.      */
  23.     int ws = node.waitStatus;
  24.     if (ws < 0)
  25.         compareAndSetWaitStatus(node, ws, 0);
  27.     /*
  28.      * Thread to unpark is held in successor, which is normally
  29.      * just the next node.  But if cancelled or apparently null,
  30.      * traverse backwards from tail to find the actual
  31.      * non-cancelled successor.
  32.      */
  33.     Node s = node.next;
  34.     if (s == null || s.waitStatus > 0) {
  35.         s = null;
  36.         // 从后往前找，找到最前面的没有被 cancelled 的节点
  37.         for (Node t = tail; t != null && t != node; t = t.prev)
  38.             if (t.waitStatus <= 0)
  39.                 s = t;
  40.     }
  41.     // 唤醒下一个节点
  42.     if (s != null)
  43.         LockSupport.unpark(s.thread);
  44. }
  1. /** waitStatus value to indicate thread has cancelled */
  2. static final int CANCELLED =  1;
  3. /** waitStatus value to indicate successor's thread needs unparking */
  4. static final int SIGNAL    = -1;
  5. /** waitStatus value to indicate thread is waiting on condition */
  6. static final int CONDITION = -2;
  7. /**
  8.   * waitStatus value to indicate the next acquireShared should
  9.   * unconditionally propagate
  10.   */
  11. static final int PROPAGATE = -3;