AQS

AQS(AbstractQueuedSynchronizer)

node

node是等待队列（双向队列）的节点分别有tail与head,变量waitStatus则表示当前Node结点的等待状态，共有5种取值CANCELLED、SIGNAL、CONDITION、PROPAGATE、0。

• CANCELLED(1)：表示当前结点已取消调度。当timeout或被中断（响应中断的情况下），会触发变更为此状态，进入该状态后的结点将不会再变化。
• SIGNAL(-1)：表示后继结点在等待当前结点唤醒。后继结点入队时，会将前继结点的状态更新为SIGNAL。
• CONDITION(-2)：表示结点等待在Condition上，当其他线程调用了Condition的signal()方法后，CONDITION状态的结点将从等待队列转移到同步队列中，等待获取同步锁。
• PROPAGATE(-3)：共享模式下，前继结点不仅会唤醒其后继结点，同时也可能会唤醒后继的后继结点。

0：新结点入队时的默认状态。
注意，负值表示结点处于有效等待状态，而正值表示结点已被取消。所以源码中很多地方用>0、<0来判断结点的状态是否正常。

独占

• acquire
  如果获取资源直接返回，如果没有则加入等待队列尾部，并进行获取位置，并挂起waiting，直至获取到资源

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

1. tryAcquire
   需要自行实现的方法，尝试获取锁
2. addWaiter
   把该线程加入等待队列tail，并标记为独占模式
3. acquireQueued
   使线程阻塞在等待队列中获取资源，一直获取到资源后才返回。如果在整个等待过程中被中断过，则返回true，否则返回false

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);//设置当前节点为head
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //检查状态是否已经排到与挂起，如果没有则进行挂起操作,此处会挂起waiting
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;//没有挂起，并且当前状态是interrupted为true
            }
        } finally {
            if (failed)//如果等待过程中没有成功获取资源（如timeout，或者可中断的情况下被中断了），那么取消结点在队列中的等待
                cancelAcquire(node);
        }
    }

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)//等待前节点signal通知，不需要做处理，正在park也不需要再次park
            return true;
        if (ws > 0) {
            //前节点没用了，那么就继续找正常节点，然后排在它后面
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            //设置前一个节点为signal，释放资源的时候通知
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);//park当前线程
        return Thread.interrupted();//返回当前线程是否中断状态
    }

4. selfInterrupt
   中断自己

• release
  尝试释放资源，如果释放成功则唤醒后续节点

public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head; //其实就是当前节点
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

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) {//如果取消了，比如timeout
            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);//唤醒线程
    }

共享

• acquireShared
  尝试获取资源，如果获取不到资源则添加到等待队列

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

private void doAcquireShared(int arg) {
        final Node node = addWaiter(Node.SHARED);//添加到tail为共享模式
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

• releaseShared