AQS的原理
AQS: AbstractQueuedSynchronizer的简称，在jdk中，我们可以发现，这是一个抽象类，需要我们实现tryAcquire和tryRelease方法。是我们可以自己实现锁的一种方式。
1.使用方法
- 自定义Sync类，继承自AbstractQueuedSynchronizer,实现其tryAcquire()和tryRelease()方法。
- 自定义MyLock类，继承自Lock，实现其相应的方法，重要的是lock与unLock方法，在这两个方法中，分别调用Sync.acquire()与Sync.release方法。在AQS类内部,acquire会调用tryAcquire，release会调用tryRelease方法。
- 在需要锁的地方，使用MyLock.lock及MyLock.unLock来实现锁的添加和消除。而Sync类，则做为MyLock的内部类来调用，不被外界使用
2.原理
以下我们会以ReentrantLock为例来讲解，先看AbstractQueueSynchronizer类：
AbstractQueuedSynchronizer.java
private transient volatile AbstractQueuedSynchronizer.Node head;
private transient volatile AbstractQueuedSynchronizer.Node tail;
private volatile int state;
protected final int getState() {
return this.state;
}
protected final void setState(int var1) {
this.state = var1;
}
protected final boolean compareAndSetState(int var1, int var2) {
return unsafe.compareAndSwapInt(this, stateOffset, var1, var2);
}
通过上述代码，需要注意关键的点：变量state及方法compareAndSetState,通过这两个定义，我们可以推出，AQS内部锁机制，实际还是通过CAS机制来进行的。
我们查看ReentrantLock.FairSync的代码
FairSync extends ReentrantLock.Sync
protected final boolean tryAcquire(int var1) {
Thread var2 = Thread.currentThread();
int var3 = this.getState();
if (var3 == 0) {
if (!this.hasQueuedPredecessors() && this.compareAndSetState(0, var1)) {
this.setExclusiveOwnerThread(var2);
return true;
}
} else if (var2 == this.getExclusiveOwnerThread()) {
int var4 = var3 + var1;
if (var4 < 0) {
throw new Error("Maximum lock count exceeded");
}
this.setState(var4);
return true;
}
return false;
}
通过代码可以看出，在ReentrantLock中，其lock的实现，就是用到了AbstractQueuedSynchronizer提供的compareAndSetState,即CAS的原理。所以在理解AQS的时候，一定要知道其内部state的作用。
3.AQS的队列(CLH队列)
对于已获得锁的线程可以去执行了，但对于未获得锁的线程如何处理呢，这就要用到AQS中的Q了，从上面的代码中，我们可以看到 ** AbstractQueuedSynchronizer.Node**，这就是AQS中保存的队列，申请所失败的线程，会加到队列当中，并且从代码中可以看出，队列中的结点会保存自己的前驱及后驱节点。
AbstractQueueSynchronizer.java
public final void acquire(int var1) {
if (!this.tryAcquire(var1) && this.acquireQueued(this.addWaiter(AbstractQueuedSynchronizer.Node.EXCLUSIVE), var1)) {
selfInterrupt();
}
}
final boolean acquireQueued(AbstractQueuedSynchronizer.Node var1, int var2) {
boolean var3 = true;
try {
boolean var4 = false;
while(true) {
AbstractQueuedSynchronizer.Node var5 = var1.predecessor();
if (var5 == this.head && this.tryAcquire(var2)) {
this.setHead(var1);
var5.next = null;
var3 = false;
boolean var6 = var4;
return var6;
}
if (shouldParkAfterFailedAcquire(var5, var1) && this.parkAndCheckInterrupt()) {
var4 = true;
}
}
} finally {
if (var3) {
this.cancelAcquire(var1);
}
}
}
在tryAcquire()拿锁时，如果失败了，会调用acquireQueued方法，将线程添加到队列中。
(在有的资料中，说Node添加到队列后，会进行自旋，检查自己的上一节点是否已释放锁，但检查几次后，就会停止检查，这个我还有点没明白，后续补充一下)
4.公平锁与非公平锁
在使用ReentrantLock时，其构造方法中可以传入一个boolean类型数据，来表明是否为公平锁，那什么是公平锁与非公平锁
公平锁：多线程按照申请锁的顺序来获取锁，不会出现争抢的情况。
非公平锁：多线程不会按照顺序获取锁，会先尝试去争抢锁，有可能后申请的线程比先申请的线程先抢到锁，在高并发情况下，可能会造成优先级反转和饥饿的现象。
ReentrantLock默认为非公平锁，也可指定boolean值，改为公平锁，具体公平与非公平的实现，还要比较其NonfairSync与FairSync的实现
static final class FairSync extends ReentrantLock.Sync {
protected final boolean tryAcquire(int var1) {
Thread var2 = Thread.currentThread();
int var3 = this.getState();
if (var3 == 0) {
if (!this.hasQueuedPredecessors() && this.compareAndSetState(0, var1)) {
this.setExclusiveOwnerThread(var2);
return true;
}
} else if (var2 == this.getExclusiveOwnerThread()) {
int var4 = var3 + var1;
if (var4 < 0) {
throw new Error("Maximum lock count exceeded");
}
this.setState(var4);
return true;
}
return false;
}
}
static final class NonfairSync extends ReentrantLock.Sync {
final void lock() {
if (this.compareAndSetState(0, 1)) {
this.setExclusiveOwnerThread(Thread.currentThread());
} else {
this.acquire(1);
}
}
protected final boolean tryAcquire(int var1) {
return this.nonfairTryAcquire(var1);
}
}
比较其tryAquire方法后，两者最大的区别在于!this.hasQueuedPredecessors()，在公平锁中，调用了此方法，而在非公平锁中，则没有。在此方法中，会判断线程的前驱结点线程是否在队列前面，如果是，就去尝试获取锁，达到队列前面的线程能优先获取锁，从而实现公平锁。而在非公平锁中，则不会检查此项，每个结点都会尝试拿锁，但最后不一定是最先入队的拿到锁。
5.可重入锁
广义上的可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class），这样的锁就叫做可重入锁。我们所知的ReentransLock和Synchronized.看源码，了解ReentransLock如何实现可重入的：
FairSync.java
protected final boolean tryAcquire(int var1) {
Thread var2 = Thread.currentThread();
int var3 = this.getState();
if (var3 == 0) {
if (!this.hasQueuedPredecessors() && this.compareAndSetState(0, var1)) {
this.setExclusiveOwnerThread(var2);
return true;
}
//可重入机制的关键
} else if (var2 == this.getExclusiveOwnerThread()) {
int var4 = var3 + var1;
if (var4 < 0) {
throw new Error("Maximum lock count exceeded");
}
this.setState(var4);
return true;
}
return false;
}
关键代码：var2 == this.getExclusiveOwnerThread(),通过上面，我们知道，在AQS中，通过state字段是否为0来进行CAS操作的，如果当前线程存在递归，第一次获取锁之后，state的值必然会变为了1，但递归仍在此线程中，就会再进行到此处加锁的代码，此时如果再进行CAS操作，就必然是拿锁失败，则会走到上面标粗的关键代码上，此时我们只要判断当前线程是之前拿到锁的线程，则让state++，接着往下处理即可。否则，会出现死锁的现象。
