Java 中的 ReentrantLock Semaphore ReentrantReadWriteLock等 这些同步的基础都是依靠AbstractQueuedSynchronizer的类来实现。为了方便起见下面使用AQS代替AbstractQueuedSynchronizer。
从ReentrantLock看AQS：
对于ReentrantLock 通常使用的如下：
reentrantLock.lock();
//to do something
reentrantLock.unlock();
它可以保证to do something 这段代码在同一个时间有且只有一个线程执行这断代码，其余的现场将被挂起，直到获得锁。
reentrantLock.lock()的实现：
public void lock() {
sync.lock();
}
ReentrantLock内部有一个代理类来具体的完成这个操作，ReentrantLock主要分为公平锁，和非公平锁,而这个的具体实现就是拓展了AQS
abstract static class Sync extends AbstractQueuedSynchronizer {...}
static final class NonfairSync extends Sync {...}
static final class FairSync extends Sync {...}
公平锁:类似于排队一样，先到先服务的原则
非公平锁:绕过排队直接插入，当然也有插入不进去的：）
公平锁的获取:
final void lock() {
acquire(1);
}
其中acquire 方法为AQS的 acquire方法
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
这代码就是尝试的获取锁，如果获取失败，将这个请求加入的到获取锁的队列之中
tryAcquire方法在AQS类中么有给出具体的实现，显然是交给子类自己去实现:
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
那就来看一下他的子类公平锁的具体实现：
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
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;
}
方法getState 的实现是在AQS中，使用一个volatile变了来表示一个锁的使用状态
private volatile int state;
protected final int getState() {
return state;
}
如果 state == 0
表示锁没有被其他线程使用然后在调用hasQueuedPredecessors()方法判断队列是否还有其他线程,如果没有没有其他线程，说明没有其他线程正在占有锁，那就进行获取锁，将state 设置为获取状态，如果通过CAS（compareAndSetState）操作将状态为更新成功则代表当前线程获取锁，因此，将当前线程设置到AQS的一个变量中，说明这个线程拿走了锁。
如果不为0 意味着，锁已经被拿走了，但是，因为ReentrantLock是重入锁，是可以重复lock,unlock的，只要成对出现行。一次。这里还要再判断一次 获取锁的线程是不是当前请求锁的线程。如果是的，累加在state字段上就可以了。致此，如果获取到锁，那就返回true ,如果么有获取到，那就返回false,然后将获取的锁的线程放入到队列中，只是在放入到队列之前要进行包装一下:
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.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
使用当前线程通过设置mode（独占，共享）构造一个node节点，创建这个节点加入到队列的尾部,如果队列不为空队列，那么通过CAS操作将当前节点设置为最新想获取锁的节点,如果失败则将进入一个死循环进行更改。将获取锁的节点加入到队列还需要将当前线程挂起
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 GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
if (p == head && tryAcquire(arg)) 如果当前的节点是head说明他是队列中第一个“有效的”节点，因此尝试获取，上文中有提到这个类是交给子类去扩展的, shouldParkAfterFailedAcquire(p, node) 否则，检查前一个节点的状态为，看当前获取锁失败的线程是否需要挂起。/如果需要，借助JUC包下的LockSopport类的静态方法Park挂起当前线程。知道被唤醒。
获取锁，说完了，释放锁也有异曲同工之妙，和获取锁的相应对应，获取一个锁，标示为+1，释放一个锁，标志位-1。具体的释放过程也只子类自己去实现:
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread()) //如果释放的线程和获取锁的线程不是同一个，抛出非法监视器状态异常。
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {//因为是重入的关系，不是每次释放锁c都等于0，直到最后一次释放锁时，才通知AQS不需要再记录哪个线程正在获取锁。
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
释放锁成功过后，找到AQS头节点，并且进行唤醒线程,寻找的顺序是从队列尾部开始往前去找的最前面的一个waitStatus小于0的节点
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 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);
}
公平锁，获取和释放都说完了，那非公平的获取和释放那就很好理解了，他们之间的区别就在于非公平的锁，在获取的时候进行更改，如果更改不成功那还是要入队列的
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
AQS只是维护一个状态，一个控制各个线程何时可以访问的状态，它只对状态负责，而这个状态表示什么含义，由子类自己去定义。