A.Q.S源码分析（exclusive模式下加锁）

exclusive mode加锁：

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

1 首先尝试加锁，其中tryAcquire需要子类实现。里面的主要的逻辑是使用CAS把状态修改为arg，如果CAS修改成功，那么标志加锁成功。如果失败，调用addWaiter

private Node addWaiter(Node mode) {        Node node = new Node(Thread.currentThread(), mode);        // Try the fast path of enq; backup to full enq on failure        Node pred = tail;        if (pred != null) {            node.prev = pred;            if (compareAndSetTail(pred, node)) {                pred.next = node;                return node;            }        }        enq(node);        return node;    }

2 上面是addWaiter的逻辑，首先把当前线程包装成一个node，然后尝试把node设置为CLH等待队列的尾部。如果失败，那么调用enq，循环CAS，直到成功。可以看到入队是通过CAS实现的。

3 把当前线程入队后，调用acquireQueued方法，下面是代码：

final boolean acquireQueued(final Node node, int arg) {        try {            boolean interrupted = false;            for (;;) {                final Node p = node.predecessor();                if (p == head && tryAcquire(arg)) {                    setHead(node);                    p.next = null; // help GC                    return interrupted;                }                if (shouldParkAfterFailedAcquire(p, node) &&                    parkAndCheckInterrupt())                    interrupted = true;            }        } catch (RuntimeException ex) {            cancelAcquire(node);            throw ex;        }    }

这是A.Q.S的核心逻辑，首先看shouldParhkAfterFailedAcquire方法

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {        int ws = pred.waitStatus;        if (ws == Node.SIGNAL)            /*             * This node has already set status asking a release             * to signal it, so it can safely park             */            return true;        if (ws > 0) {            /*             * Predecessor was cancelled. Skip over predecessors and             * indicate retry.             */    do {node.prev = pred = pred.prev;    } while (pred.waitStatus > 0);    pred.next = node;        } else {            /*             * waitStatus must be 0 or PROPAGATE. Indicate that we             * need a signal, but don't park yet. Caller will need to             * retry to make sure it cannot acquire before parking.              */            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);        }         return false;    }

如果前继节点的状态是signal，那么前继节点在release的时候，会唤醒当前节点，那么可以安全的阻塞了。如果前继节点是cancelled，那么需要把这些节点全部删除。如果前继节点是0或者PROPAGATE，需要把状态修改为signal。返回false的原因是需要再次调用tryAcquire确认是否能拿到锁。

如果shouldParhkAfterFailedAcquire返回true，那么parkAndCheckInterrupt会被调用，里面的逻辑很简单，调用LockSupport阻塞当前线程：

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

LockSuppot.park只有在其他线程调用unpark的时候才会返回。因为acquire是忽略其他线程的interrupt的，有上层代码处理。

再返回到acquireQueued方法，检查前继节点是否是头结点（头结点就是当前拿到锁的线程的节点），如果是再次尝试加锁，如果成功，那么把头结点设置为当前节点。如果失败，那么再次阻塞自己。

可以看到acquire的主要逻辑是首先尝试加锁，如果加锁失败，那么把线程放到CLH队列中然后阻塞。其他线程release唤醒后，继续尝试加锁，如果失败，再次阻塞的这样一个循环。