AQS的源码理解

AQS的成员变量

1. private volatile int state :用于判断共享资源是否被占用的标记位。0表示未被占用
2. Node head 、tail ：两个节点，一个头结点，一个尾结点
   Node的成员变量
   2.1. CANCELLED = 1：当前节点从同步队列中取消
   2.2. SIGNAL = -1：后继节点的线程处于等待状态，如果当前节点释放同步状态会通知后继节点，使得后继节点的线程继续运行。
   2.3. CONDITION = -2：节点在等待队列中，节点线程等待在Condition上，当其他线程对Condition调用了 signal()方法后，该节点将会从等待队列中转移到同步队列中，加入到对同步状态的获取中。
   2.4. PROPAGATE = -3：表示下一次共享式同步状态获取将会无条件地被传播下去。
   2.5. int waitState ： 等待状态就是上面的四种
   2.6. Thread thread ： 线程对象
   2.7. prev ： 前一个节点
   2.8. next ： 后一个节点

尝试获取锁（修改标志位），立即返回——tryAcquire

//判断是否获取锁，如果获取锁就修改标志位为arg

	protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

获取锁（修改标志位），愿意进入队列等待，直到获取——acquire

因为被public final，所以之后调用一定是调用的这个方法，意思是我一定能够得到锁。

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

这个就是首先看一下能不能尝试获取锁，如果可以直接就拿到了锁，就不需要执行下面的代码了。
如果tryAcquire没有获取锁，则继续执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg))代码。
我们首先看addWaiter(Node.EXCLUSIVE)代码

将当前线程封装成一个Node节点——addWaiter

这里就是将当前线程封装成Node节点，然后插入到队尾。

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

把节点加入到对同步状态的竞争——acquireQueued

try代码块中，主题是一个自旋操作：如果当前节点的前一个节点是头结点，而且当前线程尝试获取锁成功了，那么已经达到了目的，直接返回就好。（ps：这个头结点是虚节点，头结点并不是当前需要去拿锁的节点，它只是用来定位的，而第二个节点才是真正要去拿锁的节点，当第二个节点拿到锁之后就会变为第一个头结点。然后头节点就会出队。所以我们经常会判断当前节点的前置节点是不是头结点，也就是判断当前节点是不是要获取锁。）

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

在finally中的if语句只有在抛出异常直接进入finally块中才会执行，而cancelAcquire（node）的大致意思就是将Node的waitStatus置为CANCEL，以及其他的一些清理操作。

判断是否需要挂起当前线程——shouldParkAfterFailedAcquire

如果前一个节点的waitStatus为SINGAL，说明前置节点也在等待拿锁，需要挂起，直接返回true即可。
如果waitStatus大于0，只可能为CANAEL，所以可以将其从队列中删除。其他情况使用自旋操作让前置节点置为SINGAL，等待下一轮的判断。

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

若shouldParkAfterFailedAcquire返回true则执行挂起操作——parkAndCheckInterrupt

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

这样就保证了只有一个线程在自旋的获取锁，其他的线程都是挂起或者在挂起的路上。当有线程释放锁之后，我们就唤醒一个节点去自旋获取锁，从而形成一个良好的闭环 唤醒 获取锁 释放锁