AbstractQueuedSynchronizer 独占锁分析

独占锁， 即一次允许一个线程进入临界区。

加锁流程

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

这里首先调用tryAcquire直接去尝试获取锁， 成功就返回了。
如果失败， 这时候调用addWaiter将自己加入到等待队列，然后调用acquireQueued开始自旋或者阻塞等待加锁成功， acquireQueued返回false时表示加锁成功直接返回， 返回true时表示被设置中断标记了， 那么调用selfInterrupt中断自己。

tryAcquire

这是具体锁需要实现的方法， 一般是使用CAS增加同步变量， 成功者表示获得锁， 返回true, 下面是ReentrantLock的实现：

        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }  else if (current == getExclusiveOwnerThread()) { 
            //这里处理重入的情况
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

加入同步等待队列

同步等待队列是一个CLH队列的变体，所以加入队列的方式很简单，使用CAS设置tail指向自己，代码如下：

    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;
    }

首先根据模式和当前线程创建一个Node对象，如果tail不为空，那么做一次快速设置的尝试：将node.prev指向队列尾， 然后使用CAS设置tail指向node，设置成功的话，将原队列尾的节点的next指向node，插入成功直接返回。如果设置tail失败，那么进入enq函数。

    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

如果tail指向空，表示队列是空的，这时候需要初始化下队列（创建一个空的Node），然后把tail指向head。
如果tail不为空，和上面的样尝试插入，不成功循环继续， 直到插入成功为止。

自旋或者阻塞等待

    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. 前驱节点是head， 那么就尝试去获取锁， 获取成功的话，就出队列（将自己设置为head），返回中断状态；
2. 如果前驱节点不是head， 或者是加锁失败了， 调用shouldParkAfterFailedAcquire检查是否应该阻塞自己：
   2.1 如果需要阻塞，就调用parkAndCheckInterrupt阻塞自己，这时候线程暂停了，再次恢复时，是被其他线程唤醒了自己，这时候需要检查下线程的中断状态，如果是已经中断，那么设置返回结果为true， 在获取到锁返回后， 线程会调用selfInterrupt中断自己。
   2.2 如果不需要阻塞，那么就继续循环。
3. 流程处理失败（比如抛出异常）， 需要调用cancelAcquire，取消节点加锁请求。

检查是否应该阻塞自己

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            return true;
        if (ws > 0) {
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

是否应该阻塞自己是根据前驱节点的状态判断的：

1. 前驱节点状态是SIGNAL, 那么本节点需要阻塞， 返回true；
2. 前驱节点状态>0（只有CANCEL状态），说明前驱节点被取消了， 这时候往前搜索，找到一个非取消节点，把当前节点链接上去，返回false表明不需要阻塞自己；
3. 前驱节点的状态是0或者PROPAGATE，尝试设置前驱状态为SIGNAL, 返回false表明不需要阻塞自己；

阻塞自己

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

解锁流程

    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

调用tryRelease尝试释放自己， 如果成功的话，判断自己的状态，不为0（说明可能是CANCEL，SIGNAL或者PROPAGATE）时调用unparkSuccessor唤醒后继线程。

tryRelease

这是具体独占锁需要实现的方法，一般而言是把加上去的同步变量值减回来， 释放成功（同步变量值为0）时，返回true。 下面是ReentrantLock的实现：

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

唤醒后继者

    private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 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. 如果节点的状态是SIGNAL、PROPAGATE， 那么将自己设置为0 。
2. 检查后继节占是否为null或者是取消状态，如果是的话， 找到非取消的后继节点（因为node.next为null并不表示真的没有后继节点，需要使用tail从后往前遍历一次）。
3. 如果有非取消的后继节点，对非取消状态的后继节点调用LockSupport.unpark唤醒线程， 后继节点被唤醒后，会检查前驱的状态进行处理。

取消流程

   private void cancelAcquire(Node node) {
        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.waitStatus = Node.CANCELLED;

        if (node == tail && compareAndSetTail(node, pred)) {
            compareAndSetNext(pred, predNext, null);
        } else {
            // If successor needs signal, try to set pred's next-link
            // so it will get one. Otherwise wake it up to propagate.
            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. 清空节点的thread ；
2. 循环往前找到非取消节点，pred指向非取消节点；
3. 使predNext指向pred的下个节点（这个节点一定是取消节点）；
4. 设置当前节点状态为CANCELLED， 接下来其他线程的操作都会跳过本节点；
5. 如果当前节点是尾节点， 那么直接设置pred为尾节点；
6. 如果pred是头节点了， 那么直接调用unparkSuccessor唤醒本节点的后继节点；
7. 如果pred节点非头节点，状态为SIGNAL状态（或者非取消状态下设置状态为SIGNAL成功），thread不为空，本节点的后继是非取消状态，这些条件下使用CAS设置pred节点的后继为当前节点的后继。