JDK1.8源码学习篇一——AbstractQueuedSynchronizer学习笔记
一、引言
最近想深入学习一下java并发的基础知识，总感觉在对java.util.concurrent一知半解，很多东西好像只有点印象，这次接着学习源码的机会来深入了解一下。那么为什么把AbstractQueuedSynchronizer这个类放在最前面呢？其实相信很多人跟我有同样的经历，首先学习的是ExecuteService线程池，然后学习里面的工厂类Executors,和其中的submit、execute方法，但是学到一半的时候，发现里面很多东西用的都是锁的概念，比如我们最常用的synchronized关键字和ReentrantLock类，这里对这个也不是很了解，然后想继续学习下去，又对ReentrantLock这个类源码学习一下，最后，最后发现其中一个很核心的类AbstractQueuedSynchronizer，学习完之后，又回过头来进行总结一下，发现这个类有很多的实现子类，都是我们常用的，那么索性先把这个类放在最前面，把其中相关的方法都学习一遍。
二、AQS详解
首先，什么是AQS呢？AQS（AbstractQueuedSynchronizer)框架就是提供了一个自动管理同步状态、阻塞和非阻塞线程，以及等待队列的通用机制。内部主要包含了两个内部类一个是Node和ConditionObject，其中基于node节点构建了一个FIFO的队列，采用的是链表的数据结构进行存储。首先我们看下该类的主要结构：
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
static final class Node {}
public class ConditionObject implements Condition, java.io.Serializable {}
}可以看到其中包含了两个内部类，Node主要用作数据结构，用来保存对应的节点信息。这里面我们接着看这个抽象方法中几个比较重要的方法，tryAcquire/tryRelease/tryAcquireShared/tryReleaseShared/isHeldExclusively这个5个方法，可以看到这个5个方法都是protected类型的，所以可以让子类直接去实现它，这几个方法都没有对应的方法体，因此对应的逻辑可以写在子类中。通过tryAcquire可以获取锁，而通过tryAcquire可以去直接释放锁。AOS是一个典型的模板方法设计模式的典型运用案例，AQS为一个抽象类，却没有抽象方法，所有的方法具体实现都要子类去实现。它提供了：如何让现场如队列，如何让现场出队列，现场如何等待和转移等模板方法，而子类需要做的事情，就是如何决定线程出入队列。
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
}
protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
}
protected boolean isHeldExclusively() {
throw new UnsupportedOperationException();
}三 AQS的原理
AQS使用的是一个int类型的成员变量state来表示当前的同步状态，当state>0的时候表示已经获取到了锁，当state=0的时候，表示释放了锁，它共提供了3个方法getState(),setState()和compareAndSetState()来对同步的状态state进行操作，整个过程采用的是原子操作，保证安全性。
AQS通过内置的同步队列来完成线程的排队工作，如果当前线程获取锁失败的时候，会将当前线程以及等待状态信息的构造成一个节点，加入同步队列中，同时会阻塞当前线程，当同步锁释放的时候，则会把节点中的线程唤醒，使得其获得锁。
四、ReentrantLock简介
ReentrantLock的功能是实现代码的并发访问控制，实际上是一种排他锁，这里我们要用到的其中两个不同的锁，就NofaiSync和FairSync，就是通常所说的公平锁和非公平锁，默认的是采用非公平的锁。这里我们可以这个类的结构，其中几个几个内部类，其中Sync是一个抽象类，并且继承了AbstractQueuedSynchronizer，而NonfairSync和FairSync则是Sync的子类。两个子类都实现了tryAcquire方法用来获取锁，下图就是其中包含的主要方法和内部类名。
五、AQS的源码解析
1. 基本数据结构和知识点介绍
这里借助ReentrantLock的入口，先来了解下AQS的原理，首先来看下比较重要的一个数据结构Node节点的定义，这个用来存储等待线程的状态和信息，形成一个等待队列，具体的代码如下面所示
static final class Node {
static final Node SHARED = new Node(); //标识当前节点是共享模式
static final Node EXCLUSIVE = null; //标识当前节点是排他模式
//标识线程的等待状态，一共有四种状态，
static final int CANCELLED = 1; //表示等待线程节点已经取消
static final int SIGNAL = -1; //表示当前节点需要被激活
static final int CONDITION = -2; //表示当前节点等待在条件队列
static final int PROPAGATE = -3; //表示当前节点的后续节点的获取acquireShared被无条件执行
volatile int waitStatus;
volatile Node prev; //前驱节点
volatile Node next; //后继节点
volatile Thread thread; //当前节点的线程
Node nextWaiter; //条件队列的等待节点
final boolean isShared() { //判断当前节点是否是共享节点
return nextWaiter == SHARED;
}
//获取当前节点的前驱节点，后面的获取锁的时候，把对象加入到等待队列中，会经常用到这个方法
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
Node() {
}
Node(Thread thread, Node mode) { 等待队列使用的节点
this.nextWaiter = mode;
this.thread = thread;
}
Node(Thread thread, int waitStatus) { // 条件队列使用的节点
this.waitStatus = waitStatus;
this.thread = thread;
}
}以上是使用的数据结构的定义，在AQS还有结构非常重要的内部变量，在初始化的AQS的队列中，head和tail默认是null。
private transient volatile Node head; //等待队列的head节点，只有当调用的setHead方法的时候才进行加载，属于懒加载
private transient volatile Node tail; //等待状态的尾节点
private volatile int state; //AQS队列的状态其实上面构造的就是一个节点，这个我们可以用数据结构中的链表来表示，大致构造的如下图所示，在等待队列中有个头结点head和一个尾节点tail分别指向队列的头和尾，这是一个双向链表。
在学习源码的时候还遇到很多地方使用到了函数CompareAndSwap或者CompareAndSet方法，这些方法都是调用JDK的内部类unsafe,是基于硬件保证原子更新的，如果这个值是expect就更新为update，是无锁并发的基础。
protected final boolean compareAndSetState(int expect, int update) {
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}2. 获取锁的源码分析
首先看下程序的入口，先构建一个锁，只要执行方法lock()即可获取锁，首先来看下ReetrantLock这个锁的构造函数
ReentrantLock lock = new ReentrantLock();
lock.lock();
lock.unlock(); public ReentrantLock() {
sync = new NonfairSync(); //非公平锁
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync(); //公平锁
}
//这个方法获取锁，这里用的syn变量，这个公平锁和非公平锁的父类
public void lock() {
sync.lock();
}在这里，有公平锁和非公平锁之分，其中公平锁中，每个线程抢占锁的顺序为先后调用lock()方法的顺序依次获取锁，而非公平锁中每个线程抢占锁的顺序不确定，先获取锁，获取不到，加入到等待队列中，和调用方法lock()的顺序无关。所以这个地方在公平锁中，等待最短的时间肯定是最先获取到锁，反之在非公平锁中，等待最长的时间的线程，可能更加的有机会获取到锁。这里，我们以公平锁的源码进行分析，其实调用的是Sync的子类，FairSync和NonfairSync
abstract static class Sync extends AbstractQueuedSynchronizer {}
static final class FairSync extends Sync {}
static final class NonfairSync extends Sync {}可以看到，这个方法里面调用了acquire（）方法，并传递了一个参数1，表示需要获取锁
final void lock() {
acquire(1);
}接着往下看这个方法的内容，这个方法用了调用了两个方法作为判断是否获取到锁，其中tryAcquire 方法是AbstractQueuedSynchronizer 这个类的protected方法，由其子类去实现它，从这个&&操作符可以判断，只有当获取锁失败的的时候才会去执行下面一个方法acquireQueued()，构造一个Node，并添加到等待队列中。其实这个方法是阻塞式的。
AQS获取独占锁
1. 尝试去获取锁，tryAcquire()，获取成功，直接返回，获取失败，进行后一步操作
2.没有获取成功，把线程加入到等待队列中，当前线程中断
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}首先tryAcquire(int arg)这个方法的具体实现如下
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState(); //获取当前队列的状态
if (c == 0) { //发现所没有被获取
if (!hasQueuedPredecessors() && //这个方法点进去很简单，只有一个判断，是否存在比当前线程等待更加的线程，其实就是head==tail是否成立
compareAndSetState(0, acquires)) { //没有的话调用CAS进行更新状态，自己获取锁
setExclusiveOwnerThread(current); //
return true;
}
}
else if (current == getExclusiveOwnerThread()) { //这种状态需要判断一下，此时如果获取锁的线程等于exclusiveownerThread，则将state+1
int nextc = c + acquires; //这就是重入锁的实现方式
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}其中三个方法hasQueuedPredecessors/compareAndSetState分别用来判断和更新状态，如果此处获取失败，回到上个方法，需要进行阻塞，首先是把当前节点加入到等待队列中，首先来看下addWaiter方法
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) { //当前队列的尾节点，如果不为null，说明已经存在了等待节点，则把该节点加入到等待队列中
node.prev = pred; //这个就是链表尾部添加节点很常用的操作了，把tail节点设置成当前节点的前驱，并把tail的next属性指向自己
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node); //上一步是判断尾部节点是否null，如果为null的情况下该怎么加入呢
return node;
} private Node enq(final Node node) {
for (;;) { //for循环，一定要保证等待队列构造成功
Node t = tail;
if (t == null) { // 发现尾部节点为null一定要构造节点设置成头节点
if (compareAndSetHead(new Node()))
tail = head;
} else { //第二次循环的时候，此时已经有了头节点，把当前节点的前驱节点设置成头节点，并把自己设置成tail节点，添加到队列的最后面
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}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);
}
} private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL) //判断前驱节点的状态是否是single，来觉得是否挂起当前线程，前置节点执行完，即可唤醒当前节点，此时只要安全的挂起即可
return true;
if (ws > 0) {
do {//ws>0，说明前置节点自己取消同步状态，不需要获取锁，所以通过while循环一直往前寻找，知道找到>0的节点
node.prev = pred = pred.prev; //前驱节点被取消，跳过所有取消的前驱节点
} while (pred.waitStatus > 0); //这样做的目的是去掉同步队列中已经取消了同步的节点
pred.next = node;
} else {
//如果是其他的状态，则需要把当前的节点设置成signle，所以需要确保挂起之前不能获得同步状态
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}通过上面的操作的操作，如果一个新的线程过来，是否获取到锁，如果没有，则进入等待队列中等，获取锁则返回，这里还有一个方法cancelAcquire没讲？当初看到这里有个疑问，每个线程调用一次lock()方法去尝试获取锁，然后获取失败之后，加入到等待队列中，然后中断自己本身，那么问题来了？后面等待的线程如何又唤醒自己呢?在代码中也没看到这方面的逻辑,这里先不说，先看锁的释放逻辑。
AQS释放所独占锁
这里我们先看下锁的释放逻辑，调用unlock()方法，起调用的是tryRelease方法来释放锁。这里根据先后调用的顺序，先看下tryRelease方法
public void 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;
}具体的处理过程如下：
1. 首先等待队列的状态减1，然后判断是否是自己
2. 更新状态，释放锁
protected final boolean tryRelease(int releases) {
int c = getState() - releases; //释放一个锁，当前的状态减掉1
if (Thread.currentThread() != getExclusiveOwnerThread()) //只有自己才能释放自己
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) { //说明已经无锁
free = true;
setExclusiveOwnerThread(null);
}
setState(c); //释放一个锁，减掉1，也就是说加锁多少次，就要释放多少次
return free;
}private void unparkSuccessor(Node node) {
int ws = node.waitStatus; 获取当前节点的状态
if (ws < 0) //说明当前节点的状态并不是已经取消，那么把节点状态设置成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);
}总结下AQS释放锁的过程，释放的过程分为2步，第一是首先释放自己占有的锁，调用tryrelease方法，如果失败，则返回，如果释放锁成功，就拿到队列的头结点。第二是根据拿到的头结点，找到第一个后继的有效结点，然后将其从等待队列中移除，最后激活对应的线程。
下面看下节点的取消过程，主要是方法cancelAcquire，看下起主要的源码,其实主要就是状态设置和链表中取消一个节点的设置操作。
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;
Node predNext = pred.next; //找到node节点的后继节点
node.waitStatus = Node.CANCELLED; //同时把状态设置成取消
// If we are the tail, remove ourselves.
if (node == tail && compareAndSetTail(node, pred)) {//如果node是尾节点，就把node的前驱节点设置为尾节点，同时把对应的next设置成null
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的前驱节点不是头结点，则把状态设置成signle
Node next = node.next; //找到node的候机节点
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next); //同时进行连接，取消node的节点
} else {
unparkSuccessor(node);
}
node.next = node; // help GC
}
}以上就是AbstractQueuedSynchronizer这个类中关于获取锁和释放锁的主要的方法和流程，他是通过构造一个队列来获取锁和释放锁，当当前线程执行完毕之后，会释放当前锁，同时在激活下一个线程，还有一部分方法这里没有列出来，不如非公平锁，共享锁等，其中就是主体方法都是一样的，不过是加了一些逻辑判断，这里不再一一列出了...