（一）什么是AQS?
阅读java文档可以知道，AbstractQueuedSynchronizer是实现依赖于先进先出 (FIFO) 等待队列的阻塞锁和相关同步器（信号量、事件，等等）提供一个框架，它是一个依靠单个原子 int 值来表示状态的大多数同步器的一个基础类。在jdk中他的实现的类有Semaphore，ReentrantLock，CountDownLatch，ReentrantReadWriteLock等等很多的实现。
（二）原理
它通过实现一个volatile int state来维护线程的状态，并使用一个双向链表来维护多个线程的等待队列。一般将子类作为一个非公共的内部帮助器类。它存在有独享和共享两种模式，在独享模式下，当锁被占用时，其他线程试图获取锁一定不会成功，共享模式下其他线程获取锁可能会成功。（读写锁读-读不互斥，读-写，写-写互斥）
它提供了getState()、setState(int) ,compareAndSetState(int, int) 三个方法来获取和修改单个原子状态的方法，在使用的是我，我们只需要重写以下几个方法即可，
tryAcquire(int) (独享模式锁)tryRelease(int) （释放独享模式锁）tryAcquireShared(int)（共享模式锁）tryReleaseShared(int) （释放共享模式所）isHeldExclusively() （判断是否是独享模式锁）
（三）源码实现
acquire：
根据调用流程acquire-release来一步步分析独享模式的源码，共享模式会在后面的学习中补上，首先从acquire,锁的入口开始。
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
1)tryAcquire（int）最少会执行一次尝试去获取资源，如果获取到锁，则返回true,否则放回false。
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
tryAcquire（int）在AQS源码中直接直接抛出了一个异常，这是因为我们前面说过AQS是一个框架，使用的时候是需要我们去实现自己的核心部分的，tryAcquire（int）这里调用的实际上是在使用时我们重写的方法，通过操作state
来进行我们自己的实现的。
2）addWaiter(Node.EXCLUSIVE)将一个独占模式的线程加入到队列中队尾。
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;
}
这里的Node包含了当前线程本身以及线程的状态及以下基本信息，这里就直接看注释，我就不一一写出来了
/** Marker to indicate a node is waiting in shared mode */
static final Node SHARED = new Node();
/** Marker to indicate a node is waiting in exclusive mode */
static final Node EXCLUSIVE = null;
/** waitStatus value to indicate thread has cancelled */
static final int CANCELLED = 1;
/** waitStatus value to indicate successor's thread needs unparking */
static final int SIGNAL = -1;
/** waitStatus value to indicate thread is waiting on condition */
static final int CONDITION = -2;
/**
* waitStatus value to indicate the next acquireShared should
* unconditionally propagate
*/
static final int PROPAGATE = -3;
/**
* Status field, taking on only the values:
* SIGNAL: 值为-1，被标识为该等待唤醒状态的后继结点，当其前继结点的线程释放了同步锁或被取消，将会通知该后继结点的线程执行。说白了，就是处于唤醒状态，只要前继结点释放锁，就会通知标识为SIGNAL状态的后继结点的线程执行。
* CANCELLED: 值为1，在同步队列中等待的线程等待超时或被中断，需要从同步队列中取消该Node的结点，其结点的waitStatus为CANCELLED，即结束状态，进入该状态后的结点将不会再变化
* CONDITION: 值为-2，与Condition相关，该标识的结点处于等待队列中，结点的线程等待在Condition上，当其他线程调用了Condition的signal()方法后，CONDITION状态的结点将从等待队列转移到同步队列中，等待获取同步锁
* PROPAGATE: 值为-3，与共享模式相关，在共享模式中，该状态标识结点的线程处于可运行状态。
这里特别说下一下0状态表示为初始化状态。
addWaiter()方法创建一个当前线程节点，当尾节点不为空时，将当前节点的prev指向双向链表的尾节点，并将当前节点通过cas的方式设置为尾节点，将尾节点的next指向当前节点，成功将整个链表连起来，这就是将当前线程加入到队列的过程，返回当前创建的节点。当尾节点为空时，调用enq方法。
enq(node)方法
private Node enq(final Node node) {
for (;;) {
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;
}
}
}
}
for()循环表示自旋cas，知道成功将节点添加到队列为止，如果此时的尾节点tail为空，则创建一个空标志性的节点作为head节点，并将尾节点t也指向它，当tail不为空时，就按照前面的正常的添加节点的方式将当前节点添加到队列尾部。添加成功，退出循环，返回当前节点。
4）acquireQueued（）使线程在等待队列中获取资源，一直获取到资源后才返回。如果在整个等待过程中被中断过，则返回true，否则返回false。
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);
}
}
当线程获取资源失败，并且已经进入了队列中了，那么此时的线程就需要等待了，只等待其他线程执行完成之后，再唤醒队列中的线程时，唤醒到该线程时，该线程才可以继续执行，failed标记线程是否拿到锁，interrupted标记线程是否被中断过。自旋获取锁，
第一步，拿到当前的上一个节点，即前驱，如果上一个节点是头节点，则有资格去获取锁，可能是上一个线程释放锁之后轮到第二个线程，当有资格获取锁时，将当前节点设置成头节点，此时前面的一个节点已经出了队列了，并将前一个节点置为空，为了方便垃圾回收，返回等待过程中该线程是否被中断过。
shouldParkAfterFailedAcquire（）这个方法，我们也需要理解一下：该方法主要是用于检查状态，判读自己是否可以进入等待队列。
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;
}
从方法可以看到，当前节点的前一个节点的状态为通知状态时，返回true,即表示已经告诉了前节点，当释放之后叫醒当前节点，当ws大于0时，表示当前节点的线程被中断或者是等待超时，此时需要将该节点从队列中去除，即node.prev = pred = pred.prev和pred.next=node，表示将pred节点删除，替换成了pred的prev节点;else 则将pred节点设置成为通知唤醒状态。让前驱在执行完成后通知当前节点。
parkAndCheckInterrupt（）使线程真正的进入等待状态。
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
park()会让当前线程进入waiting状态。在此状态下，有两种途径可以唤醒该线程：1）被unpark()；2）被interrupt()，。需要注意的是，Thread.interrupted()会清除当前线程的中断标记位。
看了shouldParkAfterFailedAcquire()和parkAndCheckInterrupt()，现在让我们再回到acquireQueued()，总结下该函数的具体流程：
结点进入队尾后，检查状态，找到安全休息点；调用park()进入waiting状态，等待unpark()或interrupt()唤醒自己；被唤醒后，看自己是不是有资格能拿到号。如果拿到，head指向当前结点，并返回从入队到拿到号的整个过程中是否被中断过；如果没拿到，继续流程1。
release：
接下来看当线程释放锁，即Lock调用unlock时，源码情况：
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
release的实现就相对简单了，首先同样是调用我们用户自己实现的tryRelease()方法，当tryReleace返回true时，判断头节点状态是否等于初始值，不等于初始值时调用unparkSuccessor(node)方法释放锁，否则表示资源已经呗释放，直接返回true。
unparkSuccessor（node）:
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);
}
这个方法是用于唤醒一个线程，如果这个线程存在的话，ws小于0,表示当前线程是可以呗唤醒的，处于等待状态的线程，此时修改当前线程的状态为原始状态，如果当前线程的下一个线程为空，或者是状态大于0，表示处于CANCELLED状态，此时循环链表，找到最后一个状态小于0的线程，将找到的线程赋值给s,最后如果成功找到s，则使用unpark唤醒s节点的线程，这样就实现了release,
总结：release()是独占模式下线程释放共享资源的顶层入口。它会释放指定量的资源，如果彻底释放了（即state=0）,它会唤醒等待队列里的其他线程来获取资源。
（四） 重写tryAcquire(int) 和 tryRelease(int) 方法实现一个简易的可重入锁
这里直接使用java文档的示例代码：
class Mutex implements Lock, java.io.Serializable {
// Our internal helper class
private static class Sync extends AbstractQueuedSynchronizer {
// Report whether in locked state
protected boolean isHeldExclusively() {
return getState() == 1;
}
// Acquire the lock if state is zero
public boolean tryAcquire(int acquires) {
assert acquires == 1; // Otherwise unused
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
// Release the lock by setting state to zero
protected boolean tryRelease(int releases) {
assert releases == 1; // Otherwise unused
if (getState() == 0) throw new IllegalMonitorStateException();
setExclusiveOwnerThread(null);
setState(0);
return true;
}
// Provide a Condition
Condition newCondition() { return new ConditionObject(); }
// Deserialize properly
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0); // reset to unlocked state
}
}
// The sync object does all the hard work. We just forward to it.
private final Sync sync = new Sync();
public void lock() { sync.acquire(1); }
public boolean tryLock() { return sync.tryAcquire(1); }
public void unlock() { sync.release(1); }
public Condition newCondition() { return sync.newCondition(); }
public boolean isLocked() { return sync.isHeldExclusively(); }
public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
由于官网的文档实现的是不可重入的锁，所以本人也自己实现了一个可重入锁，下面是代码：
package com.ucar.work;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
/**
* @since: 2018/9/27
* @version: 1.0
* Copyright: Copyright (c) 2018
*/
public class MyLock implements Lock, java.io.Serializable {
private static class Sync extends AbstractQueuedSynchronizer {
@Override
protected boolean isHeldExclusively() {
return getState() == 1;
}
@Override
public boolean tryAcquire(int acquires) {
int stat = getState();
Thread thread = Thread.currentThread();
//表示线程第一次进如，直接加锁
if (stat == 0) {
compareAndSetState(0,stat+acquires);
setExclusiveOwnerThread(thread);
return true;
//当前线程等于getExclusiveOwnerThread()表示线程重入。返回true表示可以获取锁
} else if (stat != 0 && thread == getExclusiveOwnerThread()){
return true;
}
//否则返回false表示获取锁失败
return false;
}
@Override
protected boolean tryRelease(int releases) {
int stat = getState();
//stat==0表示该锁状态为释放状态，不能去释放
if (stat == 0) {
setExclusiveOwnerThread(null);
return false;
} else {
//重入的情况下减去重入次数
setState(getState()-releases);
}
//返回可释放信号
return true;
}
Condition newCondition() { return new ConditionObject(); }
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0);
}
}
private final Sync sync = new Sync();
@Override
public void lock() { sync.acquire(1); }
@Override
public boolean tryLock() { return sync.tryAcquire(1); }
@Override
public void unlock() { sync.release(1); }
@Override
public Condition newCondition() { return sync.newCondition(); }
public boolean isLocked() { return sync.isHeldExclusively(); }
public boolean hasQueuedThreads() { return sync.hasQueuedThreads(); }
@Override
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
@Override
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
}
实现细节注释已经写清楚了，这里就不在叙述了。
至于共享模式的AQS，会在以后的学习中继续记录，不足之处，忘各位大佬多多指点。
