一、什么是同步器
同步器是用来构建锁或者其他同步组件的基础框架，它使用一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作，它能实现大部分的同步需求。
同步器是实现锁的关键，在锁的实现中聚合同步器，利用同步器实现锁的语义。可以这样理解二者的关系：锁是面向使用者的，它定义了使用者与锁交互的接口（比如可以允许两个线程的并行访问），隐藏了实现细节；同步器面向的是锁的实现者，它简化了锁的实现方式，屏蔽了状态管理、线程的排队、等待与唤醒等底层操作。锁和同步容器很好地隔离了使用者和实现者所需要关注的领域。
二、同步器的基本成员（介绍常用的类好方法）
Node 是AQS的内部类构成AQS队列的一种数据结构。

站在用户的角度思考问题，与客户深入沟通，找到黄州网站设计与黄州网站推广的解决方案，凭借多年的经验，让设计与互联网技术结合，创造个性化、用户体验好的作品，建站类型包括：网站建设、成都做网站、企业官网、英文网站、手机端网站、网站推广、域名申请、雅安服务器托管、企业邮箱。业务覆盖黄州地区。

ConditionObject是AQS的内部类构成类似Object的等待/通知机制。

AQS主要成员

AQS主要方法

以上就是AQS的一些基本成员和方法，下面主要从现实的角度分析这些方法，理解这些方法的实现，能刚好的帮助我们去理解锁。
三、AQS的方法实现分析
1）、独占系列的方法
①、acquire()独占式获取同步状态，表示只会有一个线程获取，其它线程进入同步队列。
源代码如下：

// 获取锁的方法（独占模式）
    public final void acquire(int arg) {
        // tryAcquire(arg) 这个方法需要我们自己去实现,如果获取失败，
        // 调用addWaiter构造节点
        // acquireQueued
        if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

我们可以看见acquire方法内部调用了tryAcquire(arg)方法，这个方法需要构造同步组件的类自己去实现，不过返回值已经被AQS定义好了，返回true代表获取同步状态成功，返回false代表失败，需要将线程构造节点加入同步队列，就是调用acquireQueued这个方法。
acquireQueued这个方法实际是先去调用了addWaiter方法。
addWaiter(),这个方法其实就是把当前节点加入到同步队列，加入成功才返回，其实队列初始化时会制造一个空的节点，然后在空的节点后面设置同步节点（可以理解为每次获取获取锁的那个线程其实就是头结点，它是一个空的节点，结合acquireQueued方法，每次获取锁之后，该节点就会升级为头节点，并且变成一个空节点。）

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节点的上一个节点为pred（也就是尾节点）
            node.prev = pred;
            // cas设置尾节点
            if (compareAndSetTail(pred, node)) {
                // 成功后，设置pred节点的next节点为node,返回
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

acquireQueued()方法，通过上面的addWaiter方法我们已经把这个节点加入同步队列，接下来需要处理这个节点。首先判断自己的前节点是否是头结点，自己是否获取到同步状态，如果满足，把自己设置尾头结点，返回，如果不是，进入shouldParkAfterFailedAcquire（详情见后面方法分析）方法主要作用是判断自己的前置节点是否是SIGNAL状态，是的话自己就可以阻塞自己了，调用parkAndCheckInterrupt（详情见后面方法分析）方法，直到被唤醒或者中断。

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                // 获取前一个节点
                final Node p = node.predecessor();
                // p是头结点，自己获取锁成功
                if (p == head && tryAcquire(arg)) {
                                // 设置自己为头节点，变成一个空节点
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }

                // 找到前节点为signal，然后阻塞自己
                // 清理等待超时或者中断的节点
                // 尝试设置线程的状态为signal
                if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            // 出现异常
            if (failed)
                cancelAcquire(node);
        }
    }

shouldParkAfterFailedAcquire方法,这个方法主要做三件事，判断自己的前置节点是否是SIGNAL，返回true，就可以阻塞了，不是如果状态大于0，证明前面的节点被中断或者超时了，需要从队列清理了，不是大于0，就利用cas设置前置节点为SIGNAL，返回false。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node 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.
             */
            // 如果pred节点释放了状态，会通知自己
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                // 大于0证明，前面的线程等待超时或者已经被中断，需要从节点中移除
                // 需要找到不大于0的那个节点
                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.
             */
            // 找到小于等于0的前节点，设置为SIGNAL
            // 这个地方ws值只会为PROPAGATE或者0
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

parkAndCheckInterrupt方法，这个方法需要前面的方法返回true才会执行，它会阻塞node的这个线程，返回线程的中断中断状态并清理Thread.interrupted()，所以独占式获取同步状态对中断不响应的。

private final boolean parkAndCheckInterrupt() {
        // 阻塞线程
        LockSupport.park(this);
        return Thread.interrupted();
    }

cancelAcquire方法，在finally块里面，出现异常就会执行这个方法，做一些处理当前node的操作。

// 异常后，finally里面执行的方法
    private void cancelAcquire(Node node) {
        // Ignore if node doesn't exist
        if (node == null)
            return;

        node.thread = null;

        // Skip cancelled predecessors
        Node pred = node.prev;
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;

        // predNext is the apparent node to unsplice. CASes below will
        // fail if not, in which case, we lost race vs another cancel
        // or signal, so no further action is necessary.
        Node predNext = pred.next;

        // Can use unconditional write instead of CAS here.
        // After this atomic step, other Nodes can skip past us.
        // Before, we are free of interference from other threads.
        node.waitStatus = Node.CANCELLED;

        // If we are the tail, remove ourselves.
        // node是为节点，设置尾节点是pred
        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;
            // 不是头结点和尾节点，前节点是SIGNAL
            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
        }
    }

附上一张acquire独占式获取同步状态的流程图：

②、release()独占式释放同步状态,释放线程后唤醒节点。
源代码：
其中tryRelease也需要同步组件自己去实现，语义也被AQS所定义，true代表释放成功，false代表失败，如果为true，就需要决定是否去唤醒节点，首先获取同步队列的头节点，判断头结点不是空，证明有同步对别有节点才需要唤醒，判断头结点不是刚刚初始化，如果是刚刚初始化，就还没有阻塞，请参考acquire的acquireQueued处理节点的逻辑，都为true执行unparkSuccessor方法，false返回。

 public final boolean release(int arg) {
        // 释放锁
        if (tryRelease(arg)) {
            // 获取头结点
            Node h = head;
            // 头结点不为空，证明初始化了
            // 证明头结点不是刚刚创建
            // 那就可以去唤醒头结点或者它的后继节点
                        // 为0就证明没有其他节点了，不需要唤醒
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

unparkSuccessor()方法，唤醒节点，唤醒的node的后置节点，因为在获取同步状态是我们阻塞的也是后置节点，唤醒后置节点后，会去找到前节点，也就是当前的结点去获取同步状态，然后再把自己变成头结点。

private void unparkSuccessor(Node node) {
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        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);
    }

独占式释放同步状态的流程图：

③、acquireInterruptibly()响应中断的独占式获取同步状态
可以看出如果线程中断立马返回异常，然后再去执行tryAcquire()获取同步状态，获取失败执行doAcquireInterruptibly方法。

public final void acquireInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (!tryAcquire(arg))
            doAcquireInterruptibly(arg);
    }

doAcquireInterruptibly()方法，和acquire的acquireQueued的方法差不多，区别就是在parkAndCheckInterrupt这个方法如果返回true，就会抛异常InterruptedException，说明这个方法响应异常。

private void doAcquireInterruptibly(int arg)
            throws InterruptedException {
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

④、tryAcquireNanos()带时间的获取同步状态，在时间内获取到，返回true，超时返回false，首先判断线程中断状态，为true就抛异常，为false就尝试获取同步状态tryAcquire，获取失败执行doAcquireNanos方法。

public final boolean tryAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        return tryAcquire(arg) ||
                doAcquireNanos(arg, nanosTimeout);
    }

doAcquireNanos()方法,其实这个都是在acquire方法上的改进，我们看看这个方法，首先算下时间也就是deadline，然后加入同步队列addWaiter方法，然后判断node的前节点是否为头结点，是就尝试获取同步状态，都为true就返回，为false就接着算下时间，判断node前节点是否为SIGNAL，也就是shouldParkAfterFailedAcquire这个方法，为true，线程阻塞计算的时间，然后true（等待阻塞时间到）和false都判断线程中断状态，中断就抛出异常，执行异常方法，不为true，继续循环，直到获取锁或者超时。

 private boolean doAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (nanosTimeout <= 0L)
            return false;
        final long deadline = System.nanoTime() + nanosTimeout;
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return true;
                }
                nanosTimeout = deadline - System.nanoTime();
                if (nanosTimeout <= 0L)
                    return false;
                if (shouldParkAfterFailedAcquire(p, node) &&
                        nanosTimeout > spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

2）、共享系列的方法
①、acquireShared共享式获取同步状态，获取失败就加入同步队列
AQS也把语义指定好了，返货负数证明没有了，就执行doAcquireShared方法

 public final void acquireShared(int arg) {
        // 返回负数就证明没有锁了，加入同步队列
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);
    }

doAcquireShared()方法,首先构造节点加入队列addWaiter，然后获取node的前节点，判断node的前节点是否为头结点，如果是，获取资源的个数，如果资源大于等于0，调用setHeadAndPropagate方法，然后返回，不满足，调用shouldParkAfterFailedAcquire和parkAndCheckInterrupt方法和独占式一样。

private void doAcquireShared(int arg) {
        // 构建共享节点
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                // 获取node的前节点
                final Node p = node.predecessor();
                // 前节点是否是头节点
                if (p == head) {
                    // 获取锁的个数
                    int r = tryAcquireShared(arg);
                    // 大于等于0，获取锁成功
                    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);
        }
    }

setHeadAndPropagate()方法，设置头结点，设置waitStatus为Propagate，为如果还有资源，唤醒后面的节点，调用doReleaseShared方法（这个方法会在共享式释放同步状态详解）

private void setHeadAndPropagate(Node node, int propagate) {
        // 头结点
        Node h = head; // Record old head for check below
        // 设置头结点为node
        setHead(node);
        /*
         * Try to signal next queued node if:
         *   Propagation was indicated by caller,
         *     or was recorded (as h.waitStatus either before
         *     or after setHead) by a previous operation
         *     (note: this uses sign-check of waitStatus because
         *      PROPAGATE status may transition to SIGNAL.)
         * and
         *   The next node is waiting in shared mode,
         *     or we don't know, because it appears null
         *
         * The conservatism in both of these checks may cause
         * unnecessary wake-ups, but only when there are multiple
         * racing acquires/releases, so most need signals now or soon
         * anyway.
         */
        // 还有资源
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
                (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            // 当前节点的next节点是共享或者没有next节点
            if (s == null || s.isShared())
                // 唤醒后置节点
                doReleaseShared();
        }
    }

②、releaseShared()共享式释放状态
tryReleaseShared是需要同步组件自己去实现，释放成功调用doReleaseShared唤醒节点

public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

doReleaseShared()方法，方法有些复杂，不好理解，我们主要来分析三个if的含义，第一个 if (ws == Node.SIGNAL) 表示当前node需要被唤醒，然后后面利用cas设置waitStatus为0，因为是共享模式可能有多个线程同时来释放同步状态，所以只能有一个释放成功，另外一个重试；第二个else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)),其实也是用来处理并发的，当第一次并发失败的线程第二次进入时，可能会看到ws等于0（因为成功的线程设置的），所以利用cas设置为PROPAGATE，表示传递，这里补充一下不管是0或者PROPAGATE，都会被唤醒的线程利用cas设置为SIGNAL（参考shouldParkAfterFailedAcquire方法）；第三个(h == head)

1. head.waitStatus的初始值必然为SIGNAL，因此在并发时，必然只有一个线程A能将等待状态由 SIGNAL CAS更新为 0，
   该线程A会唤醒其他线程B

2. 被唤醒的线程B会首先执行setHead
   因此如果最后h!=head，说明新一轮的唤醒竞争已经开始，当前线程c已经觉察到，因此继续参与竞争，加快唤醒
   因此如果最后h==head，说明新一轮的唤醒竞争尚未开始，而被唤醒的线程B必然会开启新一轮的唤醒竞争，而当前线程c可以安心退出唤醒竞选

   private void doReleaseShared() {
       /*
        * Ensure that a release propagates, even if there are other
        * in-progress acquires/releases.  This proceeds in the usual
        * way of trying to unparkSuccessor of head if it needs
        * signal. But if it does not, status is set to PROPAGATE to
        * ensure that upon release, propagation continues.
        * Additionally, we must loop in case a new node is added
        * while we are doing this. Also, unlike other uses of
        * unparkSuccessor, we need to know if CAS to reset status
        * fails, if so rechecking.
        */
       for (;;) {
           // 头结点
           Node h = head;
           if (h != null && h != tail) {
               int ws = h.waitStatus;
               // 表示后面节点需要唤醒
               if (ws == Node.SIGNAL) {
                   // 多线程控制并发 ，可能存在多个线程同时来修改
                   if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                       continue;            // loop to recheck cases
                   unparkSuccessor(h);
               }
               // 如果ws等于0，尝试把cas设置waitStatus为PROPAGATE，传递下去
               // 请联系shouldParkAfterFailedAcquire方法一起看
               else if (ws == 0 &&
                       !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                   continue;                // loop on failed CAS
           }
           //如果头结点没有发生变化，表示设置完成，退出循环
           // 如果发生变化，加入唤醒的过程（加速唤醒，可能存在多个线程在唤醒这些node，速度比一个接一个要快）
           if (h == head)                   // loop if head changed
               break;
       }
   }

   ③、acquireSharedInterruptibly()和tryAcquireSharedNanos()一个响应中断，一个响应中断支持添加获取的超时时间（参考独占模式的这些方法）
   3）、ConditionObject系列方法
   ①、await()方法，类似Object的await方法，阻塞线程释放锁。
   我们可以看见await的第一步是调用addConditionWaiter方法，它的作用是构建等待节点加入队列的尾部，使用的也是AQS的Node,队列里面顺便也会清理清除Node不为CONDITION的节点；第二步需要释放线程获取的同步状态fullyRelease方法；第三步：阻塞线程，找到线程中断时机，也就是调用signal方法的前后顺序；第四步：调用acquireQueued方法处理节点（阻塞还是其它）；第五步：清理节点unlinkCancelledWaiters方法（清除Node不为CONDITION的节点）；第六步：响应await语义，await阻塞线程时调用interrupt方法会抛异常reportInterruptAfterWait方法。

   public final void await() throws InterruptedException {
           if (Thread.interrupted())
               throw new InterruptedException();
           // 加入等待队列，清除节点
           Node node = addConditionWaiter();
           // 释放状态
           int savedState = fullyRelease(node);
           int interruptMode = 0;
           while (!isOnSyncQueue(node)) {
               // 阻塞线程
               LockSupport.park(this);
               // 线程是被中断唤醒的
               if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                   break;
           }
           // 加入同步队列
           if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
               interruptMode = REINTERRUPT;
           if (node.nextWaiter != null) // clean up if cancelled
               // 清理节点
               unlinkCancelledWaiters();
           if (interruptMode != 0)
               // 响应中断  await语义
               reportInterruptAfterWait(interruptMode);
       }

   addConditionWaiter方法每次都是加入队列的尾部

   private Node addConditionWaiter() {
           Node t = lastWaiter;
           // If lastWaiter is cancelled, clean out.
           if (t != null && t.waitStatus != Node.CONDITION) {
               unlinkCancelledWaiters();
               t = lastWaiter;
           }
           Node node = new Node(Thread.currentThread(), Node.CONDITION);
           if (t == null)
               firstWaiter = node;
           else
               t.nextWaiter = node;
           lastWaiter = node;
           return node;
       }
               private void unlinkCancelledWaiters() {
           // 获取第一个
           Node t = firstWaiter;
           Node trail = null;
           while (t != null) {
               // 获取第一个的下一个
               Node next = t.nextWaiter;
               if (t.waitStatus != Node.CONDITION) {
                   // t需要断开连接
                   t.nextWaiter = null;
                   // 第一次trail = null
                   // firstWaiter = next
                   if (trail == null)
                       firstWaiter = next;
                   else
                       trail.nextWaiter = next;
                   if (next == null)
                       lastWaiter = trail;
               }
               else
                   trail = t;
               t = next;
           }
       }

   isOnSyncQueue方法判断node是否在同步队列中

   final boolean isOnSyncQueue(Node node) {
       // 节点状态为CONDITION ，或者node.prev == null 等待节点没有前置节点
       if (node.waitStatus == Node.CONDITION || node.prev == null)
           return false;
       // 等待节点没有next节点
       if (node.next != null) // If has successor, it must be on queue
           return true;
       /*
        * node.prev can be non-null, but not yet on queue because
        * the CAS to place it on queue can fail. So we have to
        * traverse from tail to make sure it actually made it.  It
        * will always be near the tail in calls to this method, and
        * unless the CAS failed (which is unlikely), it will be
        * there, so we hardly ever traverse much.
        */
       // 循环查找
       return findNodeFromTail(node);

   checkInterruptWhileWaiting 方法，判断是否是中断唤醒，这方法就是为了确认中断的时机是在signal的前面还是后面signal，因为需要响应中断

   private int checkInterruptWhileWaiting(Node node) {
           // 判断是否是线程中断唤醒
           return Thread.interrupted() ?
                   (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
                   0;
       }
               final boolean transferAfterCancelledWait(Node node) {
       // 设置成功表示在signal 执行之前
       if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
           enq(node);
           return true;
       }
       /*
        * If we lost out to a signal(), then we can't proceed
        * until it finishes its enq().  Cancelling during an
        * incomplete transfer is both rare and transient, so just
        * spin.
        */
       // 设置成功表示在signal 执行之后
       while (!isOnSyncQueue(node))
           Thread.yield();
       return false;
   }

   acquireQueued和unlinkCancelledWaiters方法前面都介绍过了，一个是加入同步队列，一个是清理节点，介绍下reportInterruptAfterWait方法，它是我为了响应线程Interrupt方法，interruptMode == THROW_IE只在在signal方法后调用Interrupt方法才满足，线程阻塞时调用Interrupt方法会抛异常，这是Object.await里面满足的，请参考checkInterruptWhileWaiting方法里面的transferAfterCancelledWait方法理解其实现。

   private void reportInterruptAfterWait(int interruptMode)
               throws InterruptedException {
           if (interruptMode == THROW_IE)
               throw new InterruptedException();
           else if (interruptMode == REINTERRUPT)
               selfInterrupt();
       }

   ②、awaitNanos(long nanosTimeout)和awaitUntil(Date deadline)都是提供了超时时间，和await方法类似，只是加入了时间机制。
   ③、awaitUninterruptibly不响应中断方法，发现里面都没有判断是都发生中断的标记，只有调用signal唤醒node，循环才会结束，然后调用acquireQueued处理这个节点（阻塞还是其它）

   public final void awaitUninterruptibly() {
           Node node = addConditionWaiter();
           int savedState = fullyRelease(node);
           boolean interrupted = false;
           while (!isOnSyncQueue(node)) {
               LockSupport.park(this);
               if (Thread.interrupted())
                   interrupted = true;
           }
           if (acquireQueued(node, savedState) || interrupted)
               selfInterrupt();
       }

   ④、signal方法，唤醒第一个等待队列的node。

   public final void signal() {
           // 判断是否获取锁
           if (!isHeldExclusively())
               throw new IllegalMonitorStateException();
           // 初始化
           Node first = firstWaiter;
           if (first != null)
               doSignal(first);
       }

   doSignal方法，首先把这个first节点和等待队列断开连接，然后把调用transferForSignal方法把节点从等待队列加入同步队列，唤醒节点的线程，然后被唤醒的线程就会在await方法里面执行acquireQueued这个方法。

   private void doSignal(Node first) {
           do {
               // 队列里面即将没有节点，所以首尾都要为null
               if ( (firstWaiter = first.nextWaiter) == null)
                   lastWaiter = null;
               // 把first 断开连接
               first.nextWaiter = null;
           } while (!transferForSignal(first) &&
                   (first = firstWaiter) != null);
       }
               final boolean transferForSignal(Node node) {
       /*
        * If cannot change waitStatus, the node has been cancelled.
        */
       if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
           return false;
   
       /*
        * Splice onto queue and try to set waitStatus of predecessor to
        * indicate that thread is (probably) waiting. If cancelled or
        * attempt to set waitStatus fails, wake up to resync (in which
        * case the waitStatus can be transiently and harmlessly wrong).
        */
       Node p = enq(node);
       int ws = p.waitStatus;
       if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
           LockSupport.unpark(node.thread);
       return true;
   }

   ⑤、signalAll唤醒所有等待队列的节点加入同步队列,并且清空等待队列

   public final void signalAll() {
           // 判断是否获取锁
           if (!isHeldExclusively())
               throw new IllegalMonitorStateException();
           // 获取第一个节点
           Node first = firstWaiter;
           if (first != null)
               doSignalAll(first);
       }
               private void doSignalAll(Node first) {
           // 队列设置为null
           lastWaiter = firstWaiter = null;
           // 从首节点开始加入同步队列，知道队列为空
           do {
               Node next = first.nextWaiter;
               first.nextWaiter = null;
               transferForSignal(first);
               first = next;
           } while (first != null);
       }

   四、总结

   我们学习AQS其实我觉得主要从三个方面，也就是本文的第三部分，从独占式获取和释放同步状态、共享式获取和释放同步状态和ConditionObject里面的等待/通知机制；这里在说一下独占式释放锁和共享式释放锁，独占式因为只会有一个线程获取同步状态，所以释放时也只会有一个，但是在共享这一块，我们在释放同步同步状态时可能会有多个线程同时来释放，可能出现并发的情况，理解doReleaseShared是理解共享式释放的重点；学习获取和释放同步状态，理解同步队列节点的变化是重点；学习等待/通知理解等待队列和同步队列的关系和节点的转换；只有学习好了AQS才能更好的学习后面JUC的那些锁。
   最后感慨下AQS里面的逻辑是真心有些绕，本人有些理解的可能有些不够。
   参考《Java 并发编程的艺术》