Java锁之AbstractQueuedSynchronizer

AbstractQueuedSynchronizer

一、AbstractQueuedSynchronizer

1.1 acquireQueued 同步队列中节点获取锁

当前节点的前继节点是头节点尝试获取锁，获取成功直接返回。
当前节点的前继节点不是头节点或者获取锁失败，判断当前线程是否应该Park
前继节点状态是Node.SIGNAL(当前继节点释放时会唤醒后继节点)，当前线程应该Park
前继节点状态是大于0，一直向前遍历直到找到第一个前继节点状态小于0，设置后继节点为当前节点
前继节点状态是小于等于0且不是Node.SIGNAL，设置前继节点状态为Node.SIGNAL
当前线程是需要Park时，执行Park，当执行Unpark后检查是否设置中断标志
如果获取锁期间发生异常且failed = true即没有获取到锁，同步队列中移除当前节点
向前遍历直到找到第一个前继节点状态小于0，作为有效的前继节点
如果当前节点是尾节点，则尾节点更换为前继节点
如果当前节点不是尾节点
如果前继节点不是头节点、前继节点状态是Node.SIGNAL或者成功设置为Node.SIGNAL、前继节点的线程
存在，设置前继节点的后继节点为当前节点的后继节点
否则唤醒后继节点

final boolean acquireQueued(final Node node, int arg) {
       boolean failed = true;
       try {
           boolean interrupted = false;
           for (;😉 {
    // 获取前继节点
               final Node p = node.predecessor();
               if (p == head && tryAcquire(arg)) {
                   setHead(node);
                   p.next = null; // help GC
                   failed = false;
                   return interrupted;
               }
               if (**shouldParkAfterFailedAcquire(p, node) **&&
                   parkAndCheckInterrupt())
                   interrupted = true;
           }
       } finally {
           if (failed)
               cancelAcquire(node);
       }
   }

1.2 shouldParkAfterFailedAcquire 获取锁后是否Park

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
       int ws = pred.waitStatus;
       if (ws == Node.SIGNAL)
           // 前继节点状态是Node.SIGNAL，当前继节点释放时会唤醒后继节点
           return true;
       if (ws > 0) {
           // 前继节点已经取消，一直向前遍历直到找到第一个前继节点状态小于0
           do {
               node.prev = pred = pred.prev;
           } while (pred.waitStatus > 0);
           pred.next = node;
       } else {
           /*
            waitStatus必须为0或PROPAGATE。 表示我们需要一个信号，但不要Park。 需要重试以确保在Park之前无法获取。
            */
           compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
       }
       return false;
   }

1.3 parkAndCheckInterrupt 唤醒且检查线程是否中断

private final boolean parkAndCheckInterrupt() {
       LockSupport.park(this);
       return Thread.interrupted();
   }

1.4 cancelAcquire 同步队列中移除当前节点

private void cancelAcquire(Node node) {
       // 节点为NULL直接返回
       if (node == null)
           return;

node.thread = null;

// 向前查找合适的前继节点
       Node pred = node.prev;
       while (pred.waitStatus > 0)
           node.prev = pred = pred.prev;

Node predNext = pred.next;
  // 当前节点获取锁异常设置状态为Node.CANCELLED
       node.waitStatus = Node.CANCELLED;

// 如果当前节点是尾节点则更换为pred
       if (node == tail && compareAndSetTail(node, pred)) {
           compareAndSetNext(pred, predNext, null);
       } else {
           // 如果前继节点不是头节点、前继节点状态是Node.SIGNAL或者成功设置为Node.SIGNAL、前继节点的线程存在，设置前继节点的后继节点为当前节点的后继节点
           int ws;
           if (pred != head &&
               ((ws = pred.waitStatus) == Node.SIGNAL ||
                (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
               pred.thread != null) {
               Node next = node.next;
               if (next != null && next.waitStatus <= 0)
                   compareAndSetNext(pred, predNext, next);
           } else {
               unparkSuccessor(node);
           }

node.next = node; // help GC
       }
   }

1.5 unparkSuccessor 唤醒后继节点

(1) 如果当前节点状态小于0设置为0
(2) 当前节点后继节点为NULL获取后继节点状态大于0，则从尾节点开始遍历找到最后一个节点状态小于等于0的节点
(3) 当前节点存在有效的后继节点则唤醒
private void unparkSuccessor(Node node) {
       /*
        如果状态小于0(即可能是SINGAL)，请尝试清除以预期发出信号。 如果失败或等待线程更改状态，则可以。
        */
       int ws = node.waitStatus;
       if (ws < 0)
           compareAndSetWaitStatus(node, ws, 0);

/*
       要取消驻留的线程保留在后继线程中，后者通常只是下一个节点。 但是，如果下一个节点不存在或者状态大于0，请从尾部向后移动以找到实际的未取消后继者。
        */
       Node s = node.next;
       if (s == null || s.waitStatus > 0) {
           s = null;
           for (Node t = tail; t != null && t != node; t = t.prev)
               if (t.waitStatus <= 0)
                   s = t;
       }
       if (s != null)
           LockSupport.unpark(s.thread);
   }

1.6 release 释放线程持有的锁

1.6.1 release

public final boolean release(int arg) {
  // 留给AbstractQueuedSynchronizer子类实现
       if (tryRelease(arg)) {
           Node h = head;
           if (h != null && h.waitStatus != 0)
    // 传送门 1.5
               unparkSuccessor(h);
           return true;
       }
       return false;
   }

1.6.2 releaseShared

public final boolean releaseShared(int arg) {
       if (tryReleaseShared(arg)) {
           doReleaseShared();
           return true;
       }
       return false;
   }

1.6.2.1 doReleaseShared

private void doReleaseShared() {
       for (;😉 {
           Node h = head;
           if (h != null && h != tail) {
     int ws = h.waitStatus; 
// 如果head的waitStatus为SIGNAL，一定是它的后继节点设置的，共享模式下要唤醒它的后继
               if (ws == Node.SIGNAL) {
   // 先将head的waitStatus设置为0,成功后唤醒其后继
                   if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                       continue;
   // 若成功唤醒了它的后继，它的后继就会去获取锁，如果获取成功，会造成head的改变
                   unparkSuccessor(h);
               }
     // 没有后继结点,设为PROPAGATE
               else if (ws == 0 &&
                        !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                   continue;  
           }
 // 若head发生改变,说明后继成功获取了锁，此时要检查新head的waitStatus，判断是否继续唤醒(下次循环)，head没有发生改变则停止持续唤醒
           if (h == head)  
               break;
       }
   }

1.7 独占式获取锁

1.7.1 acquire

public final void acquire(int arg) {
       if (!tryAcquire(arg) &&
          ** acquireQueued(addWaiter(Node.EXCLUSIVE), arg)**)
           selfInterrupt();
   }

1.7.2 acquireInterruptibly

public final void acquireInterruptibly(int arg)
           throws InterruptedException {
       if (Thread.interrupted())
           throw new InterruptedException();
       if (!tryAcquire(arg))
          ** doAcquireInterruptibly(arg);**
   }

1.7.2.1 doAcquireInterruptibly

// acquireQueued 传送门1.1
private void doAcquireInterruptibly(int arg)
       throws InterruptedException {
       final Node node = addWaiter(Node.EXCLUSIVE);
       boolean failed = true;
       try {
           for (;😉 {
               final Node p = node.predecessor();
               if (p == head && tryAcquire(arg)) {
                   setHead(node);
                   p.next = null; // help GC
                   failed = false;
                   return;
               }
               if (shouldParkAfterFailedAcquire(p, node) &&
                   parkAndCheckInterrupt())
                   throw new InterruptedException();
           }
       } finally {
           if (failed)
// 传送门 1.4
               cancelAcquire(node);
       }
   }

1.8 共享式获取锁

1.8.1 acquireShared

public final void acquireShared(int arg) {
       if (tryAcquireShared(arg) < 0)
           doAcquireShared(arg);
   }

1.8.1.1 doAcquireShared

private void doAcquireShared(int arg) {
       final Node node = addWaiter(Node.SHARED);
       boolean failed = true;
       try {
           boolean interrupted = false;
           for (;😉 {
               final Node p = node.predecessor();
               if (p == head) {
                   int r = tryAcquireShared(arg);
                   if (r >= 0) {
  // 设置队列头，并检查后继者是否可能在共享模式下等待，如果正在传播，则传播是否设置为propagate > 0或PROPAGATE状态。
                       setHeadAndPropagate(node, r);
                       p.next = null; // help GC
                       if (interrupted)
                           selfInterrupt();
                       failed = false;
                       return;
                   }
               }
               if (shouldParkAfterFailedAcquire(p, node) &&
                   parkAndCheckInterrupt())
                 **  interrupted = true;**
           }
       } finally {
           if (failed)
// 传送门 1.4
               cancelAcquire(node);
       }
   }

1.8.2 acquireSharedInterruptibly

public final void acquireSharedInterruptibly(int arg)
           throws InterruptedException {
       if (Thread.interrupted())
           throw new InterruptedException();
       if (tryAcquireShared(arg) < 0)
           doAcquireSharedInterruptibly(arg);
   }

1.8.2.1 doAcquireSharedInterruptibly

private void doAcquireSharedInterruptibly(int arg)
       throws InterruptedException {
       final Node node = addWaiter(Node.SHARED);
       boolean failed = true;
       try {
           for (;😉 {
               final Node p = node.predecessor();
               if (p == head) {
                   int r = tryAcquireShared(arg);
                   if (r >= 0) {
  // 设置队列头，并检查后继者是否可能在共享模式下等待，如果正在传播，则传播是否设置为传播> 0或PROPAGATE状态。
                       setHeadAndPropagate(node, r);
                       p.next = null; // help GC
                       failed = false;
                       return;
                   }
               }
               if (shouldParkAfterFailedAcquire(p, node) &&
                   parkAndCheckInterrupt())
                   throw new InterruptedException();
           }
       } finally {
           if (failed)
// 传送门 1.4
               cancelAcquire(node);
       }
   }

1.8.2.2 setHeadAndPropagate

// propagate是资源剩余量
private void setHeadAndPropagate(Node node, int propagate) {
  // 将旧的头结点先记录下来
       Node h = head;
  // 将当前node线程设为头结点,node已经获取了锁
       setHead(node);
  // 如果资源有剩余量，或者原来的头结点的waitStatus小于0，进一步检查node后继节点是否也是共享模式
       if (propagate > 0 || h == null || h.waitStatus < 0 ||
           (h = head) == null || h.waitStatus < 0) {
           Node s = node.next;
// 如果后继节点是共享模式或者现在还看不到后继的状态，则都继续唤醒后继线程
           if (s == null || s.isShared())
               doReleaseShared();
       }
   }

二、ConditionObject

2.1 唤醒条件队列中的节点

2.1.1 signal 唤醒条件队列中一个节点

public final void signal() {
           if (!isHeldExclusively())
               throw new IllegalMonitorStateException();
           Node first = firstWaiter;
           if (first != null)
               doSignal(first);
       }

// 直到条件队列中节点第一个进入同步对列为止
 private void doSignal(Node first) {
           do {
               if ( (firstWaiter = first.nextWaiter) == null)
                   lastWaiter = null;
               first.nextWaiter = null;
           } while (!transferForSignal(first) &&
**                    (first = firstWaiter) != null);**
       }

2.1.2 signalAll 唤醒条件队列中所有节点

public final void signalAll() {
           if (!isHeldExclusively())
               throw new IllegalMonitorStateException();
           Node first = firstWaiter;
           if (first != null)
               doSignalAll(first);
       }

// 不保证条件队列中所有节点都能进入同步对列
private void doSignalAll(Node first) {
           lastWaiter = firstWaiter = null;
           do {
               Node next = first.nextWaiter;
               first.nextWaiter = null;
               transferForSignal(first);
               first = next;
           } while (first != null);
       }

2.1.3 transferForSignal 条件队列中节点转移到同步队列

final boolean transferForSignal(Node node) {
       // 如果无法更改waitStatus，则该节点已被取消。
       if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
           return false;

/*
        进入到同步队列并尝试设置前继节点的waitStatus来指示线程（可能）正在等待。 如果取消设置或尝试设置waitStatus失败，请唤醒以重新同步（在这种情况下，waitStatus可能会短暂而无害地出现错误）。
        */
       Node p = enq(node);
       int ws = p.waitStatus;
  // 前继节点状态大于0表示节点已经取消或者设置状态为Node.SIGNAL失败则唤醒节点线程竞争锁。
       if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
           LockSupport.unpark(node.thread);
       return true;
   }

2.2 条件队列中节点取消等待

2.2.1 checkInterruptWhileWaiting 检查条件队列中节点是否设置中断信号

// await()  await(等待时间) awaitNanos awaitUntil 调用该方法检查是否被中断
// 条件队列中节点在等待过程中可能被其他线程设置了中断信号，需要检查中断，如果在发出信号(调用signal/signal方法)之前被中断，则返回THROW_IE；如果在发出信号(调用signal/signal方法)之后被中断，则返回REINTERRUPT；否则，则返回0。
private int checkInterruptWhileWaiting(Node node) {
           return Thread.interrupted() ?
               (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
               0;
       }

2.2.2 transferAfterCancelledWait 条件队列中节点取消等待后转移到同步队列

// await(等待时间) awaitNanos awaitUntil 等待时间到达或者设置了中断标志调用该方法转移到同步队列
// 条件队列中节点取消等待后转移到同步队列。signal signalAll方法将节点转移到同步队列中。
final boolean transferAfterCancelledWait(Node node) {
       // 条件队列中节点状态成功设置为0，则进入同步队列
       if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
           enq(node);
           return true;
       }
       // 如果调用signal/signal方法，那么直到它完成enq()之前我们无法继续进行
       while (!isOnSyncQueue(node))
           Thread.yield();
       return false;
   }

2.2.3 isOnSyncQueue 检查节点是否在同步队列中

(1) 节点状态是Node.CONDITION 或者 前继节点是NULL，则节点不在同步队列中。
(2) 节点后继节点不为NULL，则节点在同步队列中。
(3) 节点前继节点不为NULL，节点状态不是Node.CONDITION，且后继节点为NULL，可能是同步队列尾节点。则从同步队列尾节点开始向前便利，判断节点是否是同步队列中的节点。

final boolean isOnSyncQueue(Node node) {
       if (node.waitStatus == Node.CONDITION || node.prev == null)
           return false;
       if (node.next != null) // If has successor, it must be on queue
           return true;
       /*
        node.prev可以为非null，但尚未排队，因为将节点放入队列的CAS可能会失败。 因此，我们必须从尾部开始遍历以确保它确实做到了。 在此方法的调用中，它将始终处于尾部，除非CAS失败（这不太可能），否则它将一直存在，因此我们几乎不会遍历太多。
        */
       return findNodeFromTail(node);
   }

2.2.4 findNodeFromTail 从尾向前搜索节点是否在同步队列中

如果节点在同步队列中（从尾向前搜索），则返回true。仅在isOnSyncQueue需要时调用。
private boolean findNodeFromTail(Node node) {
       Node t = tail;
       for (;😉 {
           if (t == node)
               return true;
           if (t == null)
               return false;
           t = t.prev;
       }
   }

2.3 不响应中断的等待

2.3.1 awaitUninterruptibly

public final void awaitUninterruptibly() {
// 往条件队列中添加节点
           Node node = addConditionWaiter();
// 释放节点持有的状态即锁
           int savedState = fullyRelease(node);
           boolean interrupted = false;
// 循环检测节点是否被转移到同步队列中
           while (!isOnSyncQueue(node)) {
               LockSupport.park(this);
               if (Thread.interrupted())
                   interrupted = true;
           }

// 线程被唤醒尝试获取锁 传送门：1.1
           if (acquireQueued(node, savedState) || interrupted)
               selfInterrupt();
       }

2.3.2 addConditionWaiter 添加条件队列节点

// 判断尾节点状态，如果状态不是Node.CONDITION则从头节点开始遍历删除状态不是Node.CONDITION的节点
// 创建节点并加入条件队列中
private Node addConditionWaiter() {
           Node t = lastWaiter;
           // 尾节点状态不是Node.CONDITION需要清除
           if (t != null && t.waitStatus != Node.CONDITION) {
               unlinkCancelledWaiters();
               t = lastWaiter;
           }

// 创建节点并加入条件队列中
           Node node = new Node(Thread.currentThread(), Node.CONDITION);
           if (t == null)
               firstWaiter = node;
           else
               t.nextWaiter = node;
           lastWaiter = node;
           return node;
       }

2.3.2.1 unlinkCancelledWaiters 删除条件队列中状态不是CONDITION的节点

// 从头节点开始遍历删除状态不是Node.CONDITION的节点
private void unlinkCancelledWaiters() {
           Node t = firstWaiter;
           Node trail = null;
           while (t != null) {
               Node next = t.nextWaiter;
               if (t.waitStatus != Node.CONDITION) {
                   t.nextWaiter = null;
                   if (trail == null)
                       firstWaiter = next;
                   else
                       trail.nextWaiter = next;
                   if (next == null)
                       lastWaiter = trail;
               }
               else
                   trail = t;
               t = next;
           }
       }

2.3.3 fullyRelease 释放当前线程持有的锁状态

final int fullyRelease(Node node) {
       boolean failed = true;
       try {
           int savedState = getState();
// 传送门 1.6.1
           if (release(savedState)) {
               failed = false;
               return savedState;
           } else {
               throw new IllegalMonitorStateException();
           }
       } finally {
           if (failed)
               node.waitStatus = Node.CANCELLED;
       }
   }