AQS

public abstract class AbstractQueuedSynchronizerextends AbstractOwnableSynchronizerimplements java.io.Serializable ...

AQS即AbstractQueuedSynchronizer（抽象队列同步器），是其他同步器的一个抽象类
它继承了一个AOS（AbstractOwnableSynchronizer），AOS仅仅用于保存占有锁的线程

部分重要属性

AbstractQueuedSynchronizer部分属性及内部类如下：

//同步队列的队列头
private transient volatile Node head;
//同步队列的队列尾
private transient volatile Node tail;
//状态值，代表的含义与具体的实现类相关
private volatile int state;
//与Condition相关，可以实现精确唤醒
public class ConditionObject{//条件队列的队列头private transient Node firstWaiter;//条件队列的队列尾private transient Node lastWaiter;}
//队列的每一个节点,对应一个线程
static final class Node {// 分别表示共享模式和排他模式static final Node SHARED = new Node();static final Node EXCLUSIVE = null;// 表示当前节点任务已被取消static final int CANCELLED =  1;// 表示后面的一个线程待唤醒static final int SIGNAL    = -1;// 表示当前节点为条件节点,static final int CONDITION = -2;// 表示releaseShared时应该传播到其他节点static final int PROPAGATE = -3;// 等待状态,初始值为0,也可取以上的值volatile int waitStatus;// 分别表示前一个,后一个节点volatile Node prev;volatile Node next;//Node节点对应的线程对象volatile Thread thread;// 指向下一个对应特殊Condition对象的节点或者SHARED的节点Node nextWaiter;
}

AQS的模板方法

AQS类定义了几个模板方法，待子类重写。可以看到，AQS提供了独占（排他）、非独占（共享）两种模式，只需重写其中需要使用的即可。

//分别以排他、共享模式尝试获取锁对象
protected boolean tryAcquire(int arg) {throw new UnsupportedOperationException();
}
protected int tryAcquireShared(int arg) {throw new UnsupportedOperationException();
}
//分别以排他、共享模式尝试释放锁对象
protected boolean tryRelease(int arg) {throw new UnsupportedOperationException();
}
protected boolean tryReleaseShared(int arg) {throw new UnsupportedOperationException();
}
//返回当前线程是否是排他模式占有了锁
protected boolean isHeldExclusively() {throw new UnsupportedOperationException();
}

AQS中几个重要的方法

占用锁acquire

从acquire入手

	// 尝试 独占 锁对象public final void acquire(int arg) {if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}

tryAcquire(arg)交由子类重写,暂不分析
现在分别分析addWaiter(Node mode)和acquireQueued(final Node node, int arg)

	// 添加进等待队列并返回private Node addWaiter(Node mode) {Node node = new Node(Thread.currentThread(), mode);// 如果已经存在等待队列,则直接添加,否则需要先构建等待队列Node pred = tail;if (pred != null) {node.prev = pred;if (compareAndSetTail(pred, node)) {pred.next = node;return node;}}enq(node);return node;}// 初始化等待队列,在头结点处会形成一个空节点,而后向队列中加入node节点private Node enq(final Node node) {for (;;) {Node t = tail;if (t == null) { // Must initializeif (compareAndSetHead(new Node()))tail = head;} else {node.prev = t;if (compareAndSetTail(t, node)) {t.next = node;return t;}}}}// 加入等待队列后,如果条件满足,可以再尝试一遍获取锁对象,还是获取不到就进行阻塞,等待唤醒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);}}

接下来,分析shouldParkAfterFailedAcquire(Node pred, Node node)、parkAndCheckInterrupt()与cancelAcquire(Node node)
对于shouldParkAfterFailedAcquire(Node pred, Node node)方法,每个节点第一次调用时,前置节点的waitStatus为0。所以，第一次会返回false，acquireQueued(final Node node, int arg)方法中的if (p == head && tryAcquire(arg))在阻塞前会运行两次。

	// 返回当前线程是否应该阻塞(由前置节点的waitStatus决定),可以查看本文开头关于Node属性的解释private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {int ws = pred.waitStatus;// 如果前置节点的waitStatus为SIGNAL(-1),则返回trueif (ws == Node.SIGNAL)return true;// 如果>0(其实就是1,代表被取消),则跳过被取消的节点if (ws > 0) {do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0);pred.next = node;} else {compareAndSetWaitStatus(pred, ws, Node.SIGNAL);}return false;}// 阻塞线程,返回是否中断private final boolean parkAndCheckInterrupt() {LockSupport.park(this);return Thread.interrupted();}// 取消节点任务private void cancelAcquire(Node node) {if (node == null)return;// 被取消的节点中的thread置空node.thread = null;Node pred = node.prev;// 向前找到一个非取消的节点记为pred，修改node的前驱指针指向predwhile (pred.waitStatus > 0)node.prev = pred = pred.prev;Node predNext = pred.next;// 改状态node.waitStatus = Node.CANCELLED;// 如果node为尾节点，则将pred设置为尾节点if (node == tail && compareAndSetTail(node, pred)) {compareAndSetNext(pred, predNext, null);} else {int ws;// 如果pred不是头节点，将其waitStatus设置为SIGNAL，如果pred的thread不为空，则进行下一步if (pred != head &&((ws = pred.waitStatus) == Node.SIGNAL ||(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&pred.thread != null) {Node next = node.next;// 如果node的后置节点不为空，且未被取消，则将pred的后置节点设置为next节点if (next != null && next.waitStatus <= 0)compareAndSetNext(pred, predNext, next);} else {// 如果pred为头节点，则去唤醒后继节点unparkSuccessor(node);}node.next = node; // help GC}}

释放锁release

现在，分析释放锁的过程
从release入手

    public final boolean release(int arg) {if (tryRelease(arg)) {Node h = head;if (h != null && h.waitStatus != 0)unparkSuccessor(h);// 头结点为空或者头结点的waitStatus为0,则跳过unparkSuccessor(h)方法return true;}return false;}

tryRelease(arg)由子类重写，暂不分析
我们进一步分析unparkSuccessor(Node node)方法

    private void unparkSuccessor(Node node) {int ws = node.waitStatus;// 如果当前节点没有被取消，则将waitStatus设置为0if (ws < 0)compareAndSetWaitStatus(node, ws, 0);Node s = node.next;// 如果后继节点等于空或者被取消了，则从队尾开始寻找一个未被取消的非node节点的节点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);}

所以，release方法释放锁后，如果有下一个节点并且下一个节点没有被取消，则唤醒下一个节点所对应的线程
如果有下一个节点，但是下一个节点被取消了，则从队尾开始找一个没有被取消的节点，唤醒对应的线程

具体的应用有ReentrantLock、ReentrantReadWriteLock、CountDownLatch、CyclicBarrier、Semaphore等等。
学习以上类的时候，我们有两个关注点
①AQS中state字段的含义
②子类对AQS中模板方法的重写

ReentrantLock

ReentrantLock是可重入锁，重写了三个模板方法，实现了公平，非公平两种独占锁的方式。
FairSync和NonfairSync都继承Sync，Sync继承AQS

可重入的底层

①state字段表示当前线程锁占有的层数（可重入锁可重入的关键）
每进入一层，该值就+1；每出一层，该值就-1
为0时，代表没有线程占用
代码见下文

公平、非公平底层

直接查看关键代码

		// 公平地尝试获取锁protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {// 这里会判断是否有等待队列，这里就是公平的体现if (!hasQueuedPredecessors() &&compareAndSetState(0, acquires)) {// 此方法是AOS中的（本文开头已简单介绍），用于设置其中的thread对象setExclusiveOwnerThread(current);return true;}}// 可重入的关键else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0)throw new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}// 非公平地尝试获取锁final boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {// 注意此处的区别if (compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}

对于其他的应用暂不做考虑了。

推荐阅读

《The java.util.concurrent Synchronizer Framework》 JUC同步器框架（AQS框架）原文翻译