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唤醒后，继续尝试加锁，如果失败，再次阻塞的这样一个循环。