在日常开发的过程中，java.util.concurrent（J.U.C）是我们在并发编程中用的最多的，如果我们想熟练的掌握JAVA并发基础,少不了需要了解 AbstractQueuedSynchronizer（以下简写AQS）这个抽象类，因为它是 Java 并发包的基础工具类，是实现 ReentrantLock、CountDownLatch、Semaphore、FutureTask 等类的基础。 

当然这篇文章是我自己对AQS的理解，有错误之处，请评论区留言交流。

AbstractQueuedSynchronizer的类结构

//比较重要的属性都在这里
// 头结点，我是把它当成当前持有锁的线程
private transient volatile Node head;// 阻塞队列的尾节点，每个新的等待线程节点进来都插入到最后
private transient volatile Node tail;// 代表当前锁的状态，0代表没有被占用，大于 0 代表有线程持有当前锁
// 并且这个值是可以大于 1，是因为锁是可以重入的，每次重入都加上 1
private volatile int state;// 代表当前持有独占锁的线程
private transient Thread exclusiveOwnerThread;

用图片来阐述这个结构的话如下(有点丑,管用就行):

 线程的每一个等待节点都被包装成了一个Node,Node类结构如下

static final class Node {static final Node SHARED = new Node();//标识节点当前在独占模式下static final Node EXCLUSIVE = null;//代码此线程取消了争抢这个锁static final int CANCELLED =  1;//表示当前这个node的后继节点对应的线程需要被唤醒static final int SIGNAL    = -1;//表示这个节点在条件队列，后面说static final int CONDITION = -2;//后面分析static final int PROPAGATE = -3;//// 这么理解，暂时只需要知道如果这个值 大于0 代表此线程取消了等待   // 如同我们日常买东西排队一样可以排到一半，我不想买了不排队了volatile int waitStatus;// 前驱节点的引用volatile Node prev;// 后继节点的引用volatile Node next;// 线程本身volatile Thread thread;}

前面讲的都是概念，但是如果不清楚这些概念，后面可能会看不下去所以还是不要略过，下面就是真正开始分析源码了

以ReentrantLock为例子,它是我们平常用得比较多的轻量级锁，它可以分为公平锁和非公平锁，并且它是可重入的，ReentrantLock 在内部用了内部类 Sync 来管理锁，所以真正的获取锁和释放锁是由 Sync 的实现类来控制的。因为ReentrantLock可以分为公平锁和非公平锁，可以再构造ReentrantLock的时候指定

public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();
}

下面我们从非公平锁的实现 FairSync切入源码

ReentrantLock加锁 

static final class FairSync extends Sync {private static final long serialVersionUID = -3000897897090466540L;//加锁final void lock() {acquire(1);}public final void acquire(int arg) { // 首先调用tryAcquire(1)一下，顾名思义，先尝试加锁// 因为此时有可能没有线程竞争有可能直接就成功了呢，也就不需要进等待队列排队了// tryAcquire(1)没有成功，这个时候需要把当前线程挂起，放到阻塞队列中。if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {selfInterrupt();}}// 尝试直接获取锁，返回值是boolean，代表是否获取到锁// 返回true：1.没有线程在等待锁；2.重入锁// 返回false 没有抢到锁 protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();// c == 0 表名此时此刻没有线程持有锁if (c == 0) {// 虽然此时此刻锁是可以用的，但是这是公平锁，既然是公平，就得讲究先来后到，// 调用hasQueuedPredecessors()看看有没有别人在队列中等待if (!hasQueuedPredecessors() &&// 如果没有线程在等待，那就用CAS尝试一下，成功了就获取到锁了，// 不成功的话，只能说明一个问题，就在刚刚几乎同一时刻有个线程抢先了compareAndSetState(0, acquires)) {// 到这里就是获取到锁了，标记一下现在是当前这个想成占用了锁setExclusiveOwnerThread(current);//返回 return true;}}// 会进入这个分支，说明当前是有线程占用锁的，// 但是会不会是同一个线程重入了，如果是重入的线程直接state+1else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0)throw new Error("Maximum lock count exceeded");setState(nextc);return true;}}// 假设tryAcquire(arg) 返回false，那么代码将执行：// acquireQueued(addWaiter(Node.EXCLUSIVE), arg)，// 此方法的作用是把线程包装成node，同时进入到队列中// 参数mode此时是Node.EXCLUSIVE，代表独占模式private Node addWaiter(Node mode) {Node node = new Node(Thread.currentThread(), mode);// 以下几行代码想把当前node加到链表的最后面去，也就是进到阻塞队列的最后Node pred = tail;if (pred != null) { // 将当前的队尾节点，设置为自己的前驱 node.prev = pred; // 用CAS把自己设置为队尾, 如果成功了，tail == node// 这个节点成为阻塞队列新的尾巴if (compareAndSetTail(pred, node)) { // 进到这里说明设置成功，当前node==tail, 将自己与之前的队尾相连，// 上面已经有 node.prev = pred，加上下面这句，也就实现了和之前的尾节点双向连接了pred.next = node;// 线程入队了，可以返回了return node;}}// 仔细看看上面的代码，如果会到这里，// 说明 (pred = tail)==null(队列是空的) 或者 CAS失败(有线程在竞争入队)enq(node);return node;}// 能走到这个方法只有两种可能：等待队列为空，或者有线程竞争入队，// 这里会自旋配合CAS设置将自己设置为tail，竞争一次竞争不到，我就多次竞争，总会排到的private Node enq(final Node node) {for (;;) {Node t = tail;// 之前说过，队列为空也会进来这里if (t == null) { // 一开始 head 和 tail都是 null 的// 还是一步CAS，你懂的，现在可能是很多线程同时进来呢if (compareAndSetHead(new Node()))// 给后面用：这个时候head节点的waitStatus==0// 这个时候有了head，但是tail还是null，设置一下，// 把tail指向head，放心，马上就有线程要来了，到时候tail就要被抢了// 设置完了以后，继续for循环，下次就到下面的else分支了tail = head;} else {// CAS设置自己为队尾，没有设置成功的话重复尝试直到成功node.prev = t;if (compareAndSetTail(t, node)) {t.next = node;return t;}}}}// 走完addWaiter之后，回到这段代码了，// 这个时候当前节点肯定是已经成功进入了等待队列的// if (!tryAcquire(arg) //        && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) //     selfInterrupt();// 如果acquireQueued(addWaiter(Node.EXCLUSIVE), arg))返回true的话，// 此时将进入selfInterrupt()// 所以正常情况下，acquireQueued(addWaiter(Node.EXCLUSIVE), arg))应该返回false// 继续跟进看看吧final boolean acquireQueued(final Node node, int arg) {boolean failed = true;try {boolean interrupted = false;for (;;) {final Node p = node.predecessor();// p == head 说明当前节点是阻塞队列的第一个，因为它的前驱是head// 我的理解是阻塞队列其实并不包含head节点// head一般指的是占有锁的线程，head后面的才称为阻塞队列(个人理解，勿喷)// 所以这个当前节点其实可以去尝试抢一下锁// 为什么可以尝试去抢一下锁呢// 首先，它是队头，其次，当前的head有可能是刚刚初始化的node，// enq(node) 方法里面有提到，head是延时初始化的，而且new Node()的时候没有设置任何线程// 也就是说，当前的head不属于任何一个线程，所以作为队头，可以去试一试，// tryAcquire已经分析过了, 忘记了请往前看一下，就是简单用CAS试操作一下stateif (p == head && tryAcquire(arg)) {setHead(node);p.next = null; // help GCfailed = false;return interrupted;}// 到这里，说明上面的if分支没有成功，要么当前node本来就不是队头，// 要么就是tryAcquire(arg)没有抢赢别人，继续往下看if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())interrupted = true;}} finally {// 什么时候 failed 会为 true???// tryAcquire() 方法抛异常的情况if (failed)cancelAcquire(node);}}// 会到这里就是没有抢到锁,判断是否需要挂起当前线程// 第一个参数是前驱节点，第二个参数才是代表当前线程的节点private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {int ws = pred.waitStatus;// 进入阻塞队列排队的线程会将他的前驱节点设为Node.SIGNAL// 也就是说如果自己可以抢锁了就让前面的节点提醒自己，自己则被挂起等待唤醒// 前驱节点的 waitStatus == -1 ，说明前驱节点状态正常，可以直接返回if (ws == Node.SIGNAL)return true;// 前驱节点 waitStatus大于0 ，说明前驱节点取消了排队。// 前面的人都取消排队了，但是你还得依赖它来唤醒呢，// 往前遍历总能找到一个没有取消排队的节点，来提醒自己if (ws > 0) {do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0);pred.next = node;} else {// 到了这里说明前驱节点的waitStatus不等于Node.SIGNAL和CANCEL// 那也就是只可能是0，-2，-3// 都没有看到有设置waitStatus的，所以每个新的node入队时，waitStatu都是0// 用CAS将前驱节点的waitStatus设置为Node.SIGNAL(也就是-1)，让前面的提醒自己compareAndSetWaitStatus(pred, ws, Node.SIGNAL);}// 这个方法返回 false，那么会再走一次 for 循序，// 然后再次进来此方法，此时会从第一个分支返回 truereturn false;}// if (shouldParkAfterFailedAcquire(p, node) &&//                parkAndCheckInterrupt())//                interrupted = true;// 如果shouldParkAfterFailedAcquire(p, node)返回true，// 就会执行parkAndCheckInterrupt():// 这个方法很简单，因为前面返回true，所以需要挂起线程，这个方法就是负责挂起线程的// 这里用了LockSupport.park(this)来挂起线程，然后就停在这里了，等待被唤醒=======private final boolean parkAndCheckInterrupt() {LockSupport.park(this);return Thread.interrupted();}// 为什么shouldParkAfterFailedAcquire(p, node)返回false的时候不直接挂起线程：// 是为了应对在经过这个方法后，node已经是head的直接后继节点了，还需要挂起干嘛，直接可以尝试抢锁了。
}

解锁操作

// 解锁操作相比加锁还是比较简单的
public void unlock() {sync.release(1);
}
//没什么说的，继续
public final boolean release(int arg) {if (tryRelease(arg)) {Node h = head;if (h != null && h.waitStatus != 0)unparkSuccessor(h);return true;}return false;
}// 回到ReentrantLock看tryRelease方法
protected final boolean tryRelease(int releases) {int c = getState() - releases;// 没有抢到锁的不配解锁if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();// 是否完全释放锁boolean free = false;// 其实就是重入的问题，如果c==0，也就是说没有嵌套锁了，可以释放了，否则还不能释放掉if (c == 0) {free = true;setExclusiveOwnerThread(null);}setState(c);return free;
}// 唤醒后继节点
// 从上面调用处知道，参数node是head头结点
private void unparkSuccessor(Node node) {int ws = node.waitStatus;// 如果head节点当前waitStatus<0, 将其修改为0if (ws < 0)compareAndSetWaitStatus(node, ws, 0);// 下面的代码就是唤醒后继节点，但是有可能后继节点取消了等待（waitStatus==1）// 从队尾往前找，找到waitStatus<=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);
}//这个时候线程被唤醒的时候是在这里private final boolean parkAndCheckInterrupt() {LockSupport.park(this);return Thread.interrupted();}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 GCfailed = false;return interrupted;}if (shouldParkAfterFailedAcquire(p, node) &&//这里被唤醒了，然后继续检查前驱是不是头节点，尝试获取锁parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}}

至此公平锁下的加锁操作和解锁操作就都解析完了

公平锁总结

公平锁主要注意的就是下面三个方面

1. 锁状态。成员变量 “state”，它为 0 的时候代表没有线程占有锁，可以去争抢这个锁，用 CAS 将 state 设为 state + args，如果 CAS 成功，说明抢到了锁，这样其他线程就抢不到了，如果锁重入的话，state进行 +1 就可以，解锁就是减 1，直到 state 又变为 0，代表释放锁。
2. 线程的阻塞和解除阻塞。AQS 中采用了 LockSupport.park() 来挂起线程，用 LockSupport.unpark() 来唤醒线程。
3. 阻塞队列。因为争抢锁的线程可能很多，但是只能有一个线程拿到锁，其他的线程都必须等待，这个时候就需要一个 足赛队列 来管理这些线程节点，AQS 用的其实就是一个链表队列，每个 node 都持有后继节点和前驱节点的引用，大家都在里面公平的排队等待加锁，只有排到了第一个才有资格去加锁。

接下来是非公平锁，待续。。。。。。。