这个类首先是一个抽象类，定义了一个模板，很多java同步相关的类（ReetrantLock、Semaphore、CountDownLatch等)都是基于AbstractQueuedSynchronizer来实现的
AbstractQueuedSynchronizer
本身就是一个链表，提供的线程安全的操作。核心思想是通过CAS插入链表的尾部和获取链表的头结点。算法暂时先不谈，先说说他的应用，主要下先说说他的一些模板方法。
AbstractQueuedSynchronizer#acquire()
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
其中tryAcquire()就是一个模板方法，当tryAcquire()返回false的时候，就会把当前线程封装为Node(链表的数据结构)，然后挂起(使用LockSuport.park())当前线程。
其实在从队列中获取头节点的时候并恢复的时候，也会调用tryAcquire()方法，因为对一些非公平锁可能被强占。
AbstractQueuedSynchronizer#release()
和acquire()对应的就是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;
}
tryRelease()也是一个模板方法，由子类自己去实现。如果tryRelease()返回true的话，就会从链表中获取头节点（如果有)，并恢复线程。 因此，java并发包里很多都会用到这个来进行自定义。下面说举一个例子说说明如何利用上面2个模板方法来实现并发的
ReentrantLock
ReentrantLock的并发控制是通过继承AbstractQueuedSynchronizer()来实现并发的。
abstract static class Sync extends AbstractQueuedSynchronizer{
...
}
而公平锁和非公平锁又是继承了Sync， 以默认的非公平锁分析，首先来tryAcquire()，通过注释可以看出基本步骤，如果要实现公平锁也很简单，在当前线程没有占有的情况下，多增加一个判断链表是否有等待的线程即可
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
// 0 表示当前没有其他线程占用
if (c == 0) {
//通过cas的方式来设置state,如果设置成功，则认为当前线程可以获取锁，cas失败则任务其他线程比他快一步占用
if (compareAndSetState(0, acquires)) {
//设置当前线程独占
setExclusiveOwnerThread(current);
//返回true,即不需要放入等待的链表中
return true;
}
}
//如果当前线程本来就占有锁
else if (current == getExclusiveOwnerThread()) {
//占用的次数+1,这也是为什么 lock()和unlock()需要一一对应
int nextc = c + acquires;
//说明同一个线程lock()的次数为int的最大值
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
// 设置state,返回获取锁成功
setState(nextc);
return true;
}
return false;
}
再来看看tryRelease()
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
因为释放锁的时候并没有并发情况，只要保证当state为0的时候，设置独占锁为null并返回true即可。代码很简单。
小结
有人看到这里觉得，ReentrantLock是通过lock()和unlock()方法来加锁解锁的，和你说的acquire()和release()有什么关系呢？其实lock()的核心就是调用acquire(1),unlock()就是调用release(1)
AbstractQueuedSynchronizer#acquireShared()
acquireShared()和acquire()类似，只不过在调用的是
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
tryAcquireShared()是模板方法，可以简单的理解为是把boolean类型换位int类型的acquire()
AbstractQueuedSynchronizer#releaseShared()
和acquireShared()对应acquire(),releaseShared()就是对应release()，就不在赘述
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
下面再举个例子说明acquireShared()和releaseShared()的使用
Semaphore
Semaphore就是允许指定数量的线程进行入临界区。看看是什么实现，其实Semaphore的内部结构和ReentrantLock差不多，主要就是看看他是如何利用AbstractQueuedSynchronizer来实现并发的。首先看看如何利用tryAcquireShared()控制并发线程数的。
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
是不是很简单，就是利用CAS来改变available值来控制，而available就是我们自己定义的能够进入临界区的最大线程数 那么releaseShared()是怎么实现的，其实简单一想也应该是增加available值
protected final boolean tryReleaseShared(int releases) {
for (;;) {
int current = getState();
int next = current + releases;
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))
return true;
}
}
## 小节
可以看出AbstractQueuedSynchronizer主要用分为共享锁和独占锁，对于共享锁就像是一个计数器，每次获取锁的时候计数器-1，释放的时候计数器+1。
ReentrantReadWriteLock
ReentrantReadWriteLock是读写锁，每个读锁之间是不竞争锁的，但读锁和写锁、写锁和写锁之间是竞争关系。这个并发类就是综合利用上面所说的内容。首先看一下内部结构
private final ReentrantReadWriteLock.ReadLock readerLock; private final ReentrantReadWriteLock.WriteLock writerLock; final Sync sync;
成员变量分别是读锁和写锁（内部类）和一个继承了AbstractQueuedSynchronizer的Sync类，如果理解了上面的ReentrantLock和Semaphore,我们自己进行推敲一下，应该是读锁应该是和Semaphore类似，而写锁应该是和ReentrantLock类似。虽然这么说，还是有许多细节需要注意的：
- 如果保证非公平锁下，写锁不会饿死？
- 一个AbstractQueuedSynchronizer只有一个state字段，那么是如何保存读写的数量和写锁的数量呢？
- 对于读锁，如何知道当前自己持有多少个单位的锁呢
上面都是需要在设计读写锁需要考虑的地方，相信你看了源码就会知道答案！