AbstractQueuedSynchronized 以下简称AQS，是用来构建锁或者其他同步组件的基础框架。
在AQS中，为锁的获取和释放提供了一些模板方法，而实现锁的类(AQS的子类)需要实现这些模板方法中的同步方法。
这些方法包括：
·tryAcquire()：尝试以独占模式获取锁
·tryRelease()：尝试释放独占模式的锁
·tryAcquireShared()：尝试以共享模式获取锁
·tryReleaseShared()：尝试释放共享模式的锁
·isHeldExclusiverly()：返回是否以独占模式获有锁
在分析AQS的原理之前，我们先看看LockSupport、Lock，Condition、AQS、ReentrantLok等等之间的关系和使用方式。
关系图：
使用方式有两种：一种是不带条件的普通的锁，另一种是带条件的锁。
不带条件：
/* * ReentrantLock是Lock接口的实现类之一 * 实现的是一种可重入的锁 */ Lock lock = new ReentrantLock(); lock.lock(); try { //同步处理 }finally { lock.unlock(); }
带条件的锁：
Lock lock = new ReentrantLock(); Condition condition = lock.newCondition();//创建和该锁关联的条件锁 public void conditionWait() throws InterruptedException{ lock.lock(); try { condition.await(); }finally { lock.unlock(); } } public void ConditionSignal() throws InterruptedException{ lock.lock(); try { condition.signal(); }finally { lock.unlock(); } }
从使用方式可以看到，主要调用的方法就是：lock.lock()、lock.unlock()、lock.newCondition()、condition.await()、condition.signal()
下面分别来看看这几个方法：
lock.lock():由于Lock是一个接口，所以需要通过其子类来实例化，所以lock.lock()其实调用的是子类的lock()方法，在上面的例子中自然调用的就是ReentrantLock.lock()方法。
public void lock() { sync.lock(); }
可以看到，ReentrantLock.lock()方法调用的是同步器内部类的lock()方法，而ReentrantLock的内部同步器类Sync又分为FairSync和NoFairSync。
源码如下(省略了一部分内容)：
abstract static class Sync extends AbstractQueuedSynchronizer { abstract void lock(); } static final class NonfairSync extends Sync { final void lock() { if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); } } static final class FairSync extends Sync { final void lock() { acquire(1); } }
可以看到在非公平的获取锁的方法中，会首先尝试直接去获取锁，而不会通过同步队列去排队获取锁。否则的话，就通过AQS同步器的acquire(1)去获取锁。
※RetrantLock在初始化的时候可以通过参数指定是公平的还是不公平的锁。默认是非公平的锁。
lock.unlock()：调用的是同步器中的release(1)方法，也就是AQS中的release(1)方法。
public void unlock() { sync.release(1); }
lock.newCondition()：该方法调用的也是内部同步器类中的newCondition()方法。
public Condition newCondition() { return sync.newCondition(); }
在ReentrantLock的内部同步器类中的newCondition()方法如下：
final ConditionObject newCondition() { return new ConditionObject(); }
可以看到，该方法直接返回了一个AQS中的内部类ConditonObject对象。所以，在每次生成一个条件锁的时候，都会创建一个ConditionObject对象，
而每个ConditionObject对象都会在内部维护一个条件等待队列。
conditon.await():通过调用LockSupport中的park()方法，将当前挂起。
源码如下：
public final void await() throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); Node node = addConditionWaiter(); int savedState = fullyRelease(node); int interruptMode = 0; while (!isOnSyncQueue(node)) { LockSupport.park(this); if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) break; } if (acquireQueued(node, savedState) && interruptMode != THROW_IE) interruptMode = REINTERRUPT; if (node.nextWaiter != null) // clean up if cancelled unlinkCancelledWaiters(); if (interruptMode != 0) reportInterruptAfterWait(interruptMode); }
condition.signal():通过调用LockSupport的unpark()方法，来唤醒线程。
源码如下:
public final void signal() { if (!isHeldExclusively()) throw new IllegalMonitorStateException(); Node first = firstWaiter; if (first != null) doSignal(first); } private void doSignal(Node first) { do { if ( (firstWaiter = first.nextWaiter) == null) lastWaiter = null; first.nextWaiter = null; } while (!transferForSignal(first) && (first = firstWaiter) != null); }
final boolean transferForSignal(Node node) { /* * If cannot change waitStatus, the node has been cancelled. */ if (!compareAndSetWaitStatus(node, Node.CONDITION, 0)) return false; /* * Splice onto queue and try to set waitStatus of predecessor to * indicate that thread is (probably) waiting. If cancelled or * attempt to set waitStatus fails, wake up to resync (in which * case the waitStatus can be transiently and harmlessly wrong). */ Node p = enq(node); int ws = p.waitStatus; if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL)) LockSupport.unpark(node.thread); return true; }
了解完上面的概述之后，我们知道了，在不带条件的锁中，主要是通过调用AQS中的acquire(1)herelease(1)方法来获取锁和释放锁的。
下面就来具体看看AQS中的实现
在AQS中通过一个双向FIFO同步队列来维护获取对象锁的线程，当获取锁失败的时候，会用当前线程构建一个Node节点，加入到同步队列中去。
在AQS中维护了同步队列的head和tail节点，和同步状态。。
Node节点中维护了当前线程的status和前驱节点、后继节点、下一个等待节点(条件等待的时候用)。
waitStatus包含如下状态默认值为0：
CANCELLED = 1 ： 表示当前线程在等待的时候已经超时了或者被取消了
SIGNAL = -1 ：当前线程释放了同步状态或者被取消的时候会通知后继节点，使后继节点得以运行
CONDITINO = -2：节点在等待队列中，等待Condition，当其他线程在Condition上调用signal的时候，该线程会从等待队列转移到同步队列中去，加入到同步状态的获取。
PROPAGATE = -3：表示下一次共享式同步状态会无条件的传播下去
AQS中同步器的结构如下：
当有节点加入到同步队列的时候，只需要对tail节点重新指向就可以了
同步队列是一个FIFO的队列，在获取锁的时候总是首节点是获取同步状态的节点，首节点的线程在释放同步状态时，将会唤醒后继节点，而后继节点在获取同步状态成功时，会将自己设置为首节点。
下面就来具体看看在获取锁的时候lock.lock()调用的同步器中的acquire（1）方法的具体实现。
public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }
以独占模式获取锁，并且不相应中断。在AQS中还有以下acquire方法：
acquireInterruptibly(int arg) :以独占模式获取锁，并且响应中断
acquireShared(int arg):以共享模式获取锁，并且不响应中断
acquireSharedInterruptibly(int arg):以共享模式获取锁，并且响应中断
该方法首先会调用tryAcquire(arg)来尝试获取锁。从源码可以看到，在AQS中该方法只是单纯的抛出一个UnsupportedOperationException异常，该方法需要实现AQS同步器的具体类中实现。
protected boolean tryAcquire(int arg) { throw new UnsupportedOperationException(); }
我们看看ReentrantLock中的具体实现。
非公平锁：
final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { //如果当前的同步状态为0，就尝试直接设置同步状态和设置独占的线程为自己，来强制获取锁 if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { //如果当前同步状态不为0，就判断是不是自己获取了锁，这里是实现可重入的 int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; }
公平锁：
protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (!hasQueuedPredecessors() && //当前state为0 ，并且同步队列中没有前继节点，就尝试设置自己为获得锁的线程 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; }
可以看到，不论是在公平锁还是非公平锁的tryAcquire中，当获取到锁的时候返回的都是true，否则返回false。
所以，如果当前线程没有获取到锁的时候，则会继续执行后面的acquireQueued(addWaiter(Node.EXCLUSIVE),arg))
我们先看看addWaiter（Node.EXCLUSIVE）的实现。
private Node addWaiter(Node mode) { Node node = new Node(Thread.currentThread(), mode); // 首先为当前线程以指定模式构建一个Node节点，然后尝试快速入队的方式加入到同步队列中去 Node pred = tail; if (pred != null) { node.prev = pred; if (compareAndSetTail(pred, node)) { pred.next = node; return node; } } enq(node); //否则的话就调用enq(node)方法来加入到同步队列中去 return node; }
再看看enq(node)的源码实现
private Node enq(final Node node) { for (;;) { //通过一个无条件的循环，知道将构建一个空的head，然后将当前节点加入到空的head的后面，构成一个同步队列 Node t = tail; if (t == null) { // Must initialize if (compareAndSetHead(new Node())) tail = head; } else { node.prev = t; if (compareAndSetTail(t, node)) { t.next = node; return t; } } } }
再看看acquireQueued(node,int)的源码实现
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)) { //判断前一个节点是不是head节点，如果是的话，则会再次尝试去获取锁 setHead(node); p.next = null; // help GC failed = false; return interrupted; } if (shouldParkAfterFailedAcquire(p, node) && //如果前一个节点不是head节点，则设置前一个非取消节点的状态是signal，以确保在前一个线程释放锁的时候能唤醒当前线程 parkAndCheckInterrupt()) //挂起当前线程，并且返回当前线程是否被中断过(会清空中断状态，只有在被唤醒的时候才能从park（）方法返回) interrupted = true; } } finally { if (failed) cancelAcquire(node); //如果被中断过，则把该节点从同步队列中删除 } }
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { int ws = pred.waitStatus; if (ws == Node.SIGNAL) /* * This node has already set status asking a release * to signal it, so it can safely park. */ return true; if (ws > 0) { /* * Predecessor was cancelled. Skip over predecessors and * indicate retry. */ do { node.prev = pred = pred.prev; } while (pred.waitStatus > 0); pred.next = node; } else { /* * waitStatus must be 0 or PROPAGATE. Indicate that we * need a signal, but don't park yet. Caller will need to * retry to make sure it cannot acquire before parking. */ compareAndSetWaitStatus(pred, ws, Node.SIGNAL); } return false; }
private void cancelAcquire(Node node) { // Ignore if node doesn't exist if (node == null) return; node.thread = null; // Skip cancelled predecessors Node pred = node.prev; while (pred.waitStatus > 0) node.prev = pred = pred.prev; // predNext is the apparent node to unsplice. CASes below will // fail if not, in which case, we lost race vs another cancel // or signal, so no further action is necessary. Node predNext = pred.next; // Can use unconditional write instead of CAS here. // After this atomic step, other Nodes can skip past us. // Before, we are free of interference from other threads. node.waitStatus = Node.CANCELLED; // If we are the tail, remove ourselves. if (node == tail && compareAndSetTail(node, pred)) { compareAndSetNext(pred, predNext, null); } else { // If successor needs signal, try to set pred's next-link // so it will get one. Otherwise wake it up to propagate. int ws; 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 } }
acquire（1）的总结：
①首先会去调用子类实现的具体tryAcquire(1)方法来获取锁，根据子类不同，实现的也不同，例如ReentrantLock中的实现就分为公平锁和非公平锁。非公平锁就是不会去同步队列中排队，
而是直接去获取锁。如果获取失败的话，就会跟公平锁一样，进入FIFO的同步队列排队。
②加入同步队列的时候，首先会判断tail节点是否为空，如果不为空，则会尝试快速入队，如果为空的话，则会先创建一个空的head节点，然后在将当前线程的节点加入到同步队列中去
③加入到同步队列之后，会再次判断前一个节点是不是head节点，如果是的话，则会再次尝试去获取锁，如果获取失败的话，则会挂起当前线程。
④直到当前线程被唤醒的时候，会判断当前线程是否被中断过，如果被中断过，则会从同步队列中删除当前线程节点。并且中断当前线程。
下面在看看lock.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; }
首先会调用tryRelease（arg）方法来释放锁。然后唤醒后面的线程。
protected boolean tryRelease(int arg) { throw new UnsupportedOperationException(); }
tryRelease()同样也是子类需要实现的方法。ReentrantLock中的实现如下：
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; }
private void unparkSuccessor(Node node) { /* * If status is negative (i.e., possibly needing signal) try * to clear in anticipation of signalling. It is OK if this * fails or if status is changed by waiting thread. */ int ws = node.waitStatus; if (ws < 0) compareAndSetWaitStatus(node, ws, 0); /* * Thread to unpark is held in successor, which is normally * just the next node. But if cancelled or apparently null, * traverse backwards from tail to find the actual * non-cancelled successor. */ 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); }
release(1)的总结：
①首先会判断当前线程是不是独占的拥有锁。如果是的话，则会去释放锁。如果当前线程都已经退出了获取锁（可重入的原因），则会设置当前线程的state为0，独占线程为null
②在释放锁之后，会唤醒下一个等待中的线程。
AQS中条件队列的实现方式参考ConditonObject实现分析点此参考