柳丝榆荚自芳菲，不管桃飘与李飞。

前言

AQS内部维持着一个双向的同步队列，节点状态可以是共享的也可以是独占的。

构造函数

//构造函数为protected，只有子类或者同包下的类才能访问。 
protected AbstractQueuedSynchronizer() { }

属性和静态代码块

//同步队列的首结点，延迟初始化。除了初始化之外，它只通过setHead方法进行修改。
//注意:如果head存在，则保证它的status不为cancelled
private transient volatile Node head;

//同步队列的尾结点，延迟初始化。只有通过enq加入新的节点时，才会被修改。
private transient volatile Node tail;

// 同步状态
private volatile int state;

//快速自旋的时间（单位：纳秒），而不是park线程的时间。
//为了提高在短时间内的足够好的响应的一个粗略估计值。
static final long spinForTimeoutThreshold = 1000L;

//获取支持compareAndSet的一些属性
//获取Unsafe实例
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;

static {
    try {
        //获取AbstractQueuedSynchronizer类的state字段的内存地址偏移量
        stateOffset = unsafe.objectFieldOffset
            (AbstractQueuedSynchronizer.class.getDeclaredField("state"));
        //获取AbstractQueuedSynchronizer类的head字段的内存地址偏移量
        headOffset = unsafe.objectFieldOffset
           (AbstractQueuedSynchronizer.class.getDeclaredField("head"));
        //获取AbstractQueuedSynchronizer类的tail字段的内存地址偏移量
        tailOffset = unsafe.objectFieldOffset
            (AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
        //获取Node类的waitStatus字段的内存地址偏移量
        waitStatusOffset = unsafe.objectFieldOffset
            (Node.class.getDeclaredField("waitStatus"));
        //获取Node类的next字段的内存地址偏移量    
        nextOffset = unsafe.objectFieldOffset
            (Node.class.getDeclaredField("next"));

    } catch (Exception ex) { throw new Error(ex); }
}

private方法

//将队列头设置为节点，从而退出队列。
//只有获取同步状态的方法中才会调用它。
//为了GC和不必要的signal和遍历，将不使用的属性置为null。
//head节点只是获得同步状态的线程通知后继阻塞线程的载体
private void setHead(Node node) {
    head = node;
    node.thread = null;
    node.prev = null;
}

//CAS的去设置同步队列的head。只在enq方法中使用。
private final boolean compareAndSetHead(Node update) {
    //因为head节点是延迟初始化的，所以刚开始是null。
    return unsafe.compareAndSwapObject(this, headOffset, null, update);
}

//CAS的设置同步队列的tail。只在enq方法中使用。
private final boolean compareAndSetTail(Node expect, Node update) {
    return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}

//CAS的设置node的next属性
private static final boolean compareAndSetNext(Node node,
                                               Node expect,
                                               Node update) {
    return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
}

//CAS的去设置Node的status属性。
private static final boolean compareAndSetWaitStatus(Node node,
                                                     int expect,
                                                     int update) {
   //waitStatusOffset表示node对象status在内存中的地址偏移量
    return unsafe.compareAndSwapInt(node, waitStatusOffset,
                                    expect, update);
}
//将节点加入到同步队列中
//返回插入的节点在同步队列中的前一个节点
//同步队列是一个双向队列
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { 
            //因为同步队列的首尾节点是是延迟初始化的，
            //所以插入头结点时应该初始化。
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            //建立前后节点间的连接
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

//构建指定类型的节点并且加入到同步队列中。
//也可以有共享模式的节点，并且条件队列中的节点是不是也可以有这两种状态？？
//返回一个新的节点
private Node addWaiter(Node mode) {
    //mode为Node.EXCLUSIVE表示为独占模式下的节点，
    //为Node.SHARED表示共享模式下的节点。
    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;
}
//从同步队列的尾结点开始自旋寻找，查看当前节点是否在同步队列中，
//如果在同步队队列中，那么返回true。
//本方法只会在isOnSyncQueue方法中调用。
private boolean findNodeFromTail(Node node) {
    Node t = tail;
    for (;;) {
        if (t == node)
            return true;
        //表示t为头结点的前一个节点
        //已经遍历到头结点了，还是没有找到当前节点，那么返回false
        if (t == null)
            return false;
        t = t.prev;
    }
}

//如果后继节点存在，则唤醒后继节点。
private void unparkSuccessor(Node node) {
    //如果当前节点状态为负值（可能在等待signal）,在被signal之前，
    //将节点的状态设置为0。
    //如果清除状态失败或者在线程等待的时候，状态被其他线程改变了，
    //也没有关系。
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    //将要unpark的线程已经保存在后继节点中，一般就是下一个节点。
    //但是下一个节点被cancelled或者为空,那么就从后向前遍历同步队列，
    //找到non-cancelled的后继节点。
    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);
}
//获取同步状态失败之后，检查并更新当前节点的状态。
//如果当前节点的线程应该阻塞，返回true。
//这个方法是循环获取同步状态中的主要信号控制。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //pre当前节点的前一个持有同步状态的节点
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        //这个节点已经设置了前一个节点的状态，让其释放同步状态之后唤醒它。
        //那么这个节点可以安全park。
        return true;
    if (ws > 0) {
        //前一个节点被cancelled，所以需要往前遍历,
        //直到找到没有被cancelled的节点。
        //（相当于删除队列中取消状态的节点）
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        //（因为这是同步队列，节点状态不可能为condition）。
        //那么进入这个分支之后，当前节点状态只可能为初始化的0或者propagate。
        //前一个节点状态为0或者propagate，那么当前节点需要signal，但是不用park。
        //调用者需要重新尝试以确保节点在parking之前不能去获取同步状态。
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

//park当前线程，并返回线程的中断状态。
//如果线程被中断了，那么返回true。
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    //Thread.interrupted()清除线程的中断标志，并返回清除之前的中断标志。
    return Thread.interrupted();
}

//当fastppath失败的时候调用，是getFirstQueuedThread的另一个版本
private Thread fullGetFirstQueuedThread() {
   //第一个节点通常是head.next。尝试获取它的线程字段，确保一致读取:如果线程为null 
   //或者s.prev不再是head，然后在我们去取第一个线程节点的时候，
   //其他一些并发地执行setHead。
   //在从后遍历之前，我们尝试了两次。
   /**
    *将头结点赋值给h，将头结点的下一个节点赋值给s。
    *下面的检查操作执行了两次
    * (
    *       (h = head) != null && (s = h.next) != null &&
    *       s.prev == head && (st = s.thread) != null
    *)
    */
    Node h, s;
    Thread st;
    if (((h = head) != null && (s = h.next) != null &&
         s.prev == head && (st = s.thread) != null) ||
        ((h = head) != null && (s = h.next) != null &&
         s.prev == head && (st = s.thread) != null))
        return st;

    //如果head的next还没有设置，或者当setHead之后，可能head的next没有设置。
    //所以需要检查tail是不是第一个节点。如果不是，那么需要安全地从tail遍历到head，
    //找到第一个节点，确保终止。
    Node t = tail;
    Thread firstThread = null;
    while (t != null && t != head) {
        Thread tt = t.thread;
        if (tt != null)
            firstThread = tt;
        t = t.prev;
    }
    return firstThread;
}

//设置同步队列的头结点，检查后继节点，是不是在共享模式中，
//如果是在共享模式下，或者在propagate > 0或者status是propagate，
//那么传播同步状态。
private void setHeadAndPropagate(Node node, int propagate) {
    //node将要被设置为头结点的节点
    //propagate是tryAcquireShared的返回值。
    Node h = head; // Record old head for check below
    setHead(node);
    //尝试signal队列的下一个节点：
    //1.同步状态被调用者传播,或者被前一个操作记录下来
    //（在setHead的前后记录状态都是可以的）;
    //(对status采用符号校验，因为有可能status从propagate转变为signal)
    //2.并且下一个等待的节点是同步模式，
    //或者不知道处于什么状态，因为节点看起来是空的。
    //只有在多个线程竞争获取/释放同步状态，这两项检查才会导致不必要的唤醒
    //大多数线程都需要唤醒。

    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        //这里的head已经是新的头结点了
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

//取消正在尝试获取同步状态的节点
private void cancelAcquire(Node node) {
    if (node == null)
        return;

    node.thread = null;

    // 跳过已经cancelled的前继节点
    Node pred = node.prev;
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;
    Node predNext = pred.next;

    // 这里使用无条件写而不是CAS。
    //在这个原子操作之后，其他线程可以跳过该节点。
    //在这个原子操作之前，该节点可以不受其他线程的干扰。
    node.waitStatus = Node.CANCELLED;

    // 如果当前节点是尾结点，那么将前继节点设置为尾结点。
    //并将尾结点的下一个节点设置为null
    if (node == tail && compareAndSetTail(node, pred)) {
        compareAndSetNext(pred, predNext, null);
    } else {
        //如果后继节点需要signal，那么尝试设置pred的next-link，让pred有后继者，
        //否则，唤醒当前节点,传播同步状态。
        int ws;
        //1.前继节点不是头结点；
        //2.前继节点状态为signal或者<=0并设置前继节点状态为signal成功；
        //3.前继节点的线程不为空
        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.独占模式

//独占模式下可中断的获取同步状态。
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);
    }
}

//独占模式下指定等待时间的获取同步状态
//指定时间内，获取同步状态成功，返回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.共享模式

//共享模式下不可中断的获取同步状态
private void doAcquireShared(int arg) {
    final Node node = addWaiter(Node.SHARED);
    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);
    }
}


//共享模式下可中断的获取同步状态
private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

//共享模式下指定时间内获取同步状态
//如果指定时间内获取同步状态成功，返回true。
private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    if (nanosTimeout <= 0L)
        return false;
    final long deadline = System.nanoTime() + nanosTimeout;
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    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);
    }
}

//在共享模式下释放同步状态--唤醒后继者并且传播同步状态
//注意：在独占模式下，如果后继节点需要唤醒，
//释放同步状态就是相当于unpark头结点的后继节点。
private void doReleaseShared() {
    //即使有其他正在进行的同步状态的获取/释放，也要确保传播同步状态。
    //如果头结点的后继者需要signal，那么unpark后继者。
    //如果后继节点不需要signal，当头结点释放同步状态后，
    //将自己的状态设置为propagate，以确保同步状态被传播。
    //此外，必须将这些操作放在循环中，
    //以防我们做这些操作的时候，新的节点被加入进来。
    //而且，不像unparkSuccessor其他使用那样，在这里
    //需要知道CAS重置状态失败的情况，所以需要重新检查。
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            //如果头结点状态为signal，那么将自己状态修改为0，
            //修改成功后，唤醒后继节点。
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        //确保头结点在本次释放操作中没有被修改。
        if (h == head)                   // loop if head changed
            break;
    }
}

嘻嘻，如果文章有错误的地方，麻烦小哥哥小姐姐帮忙指出改正，一起学习，一起交流。