AbstractQueuedSynchronizer源码阅读和理解
简述：这个抽象类是J.U.C的锁同步的基础框架（简称：AQS），与之相关的锁同步实现类有：ReentrantLock、ReentrantReadWriteLock、Semaphore、CountDownLatch、FutureTask……这个类使用CLH队列，让我们来一探究竟。
tips：所谓CLH锁是并行计算中自旋锁的实现机制之一。
自旋的含义是如果一个Atomic寄存器的值不符合要求，就一直进行循环。这与阻塞的区别是：阻塞会产生现场恢复的开销，而自旋锁省却了这一部分，同时自旋锁需要一直占用CPU。
几个属性：
//头节点，记录的是当前正在运行的节点或者NULL
private transient volatile Node head;
//尾节点
private transient volatile Node tail;
//锁的状态，在互斥锁中它表示着线程是否已经获取了锁，0未获取，1已经获取了，大于1表示重入数。
private volatile int state;
//节点类
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;
//此节点的线程是处在一个条件队列中并不会被唤醒，只有当状态为0的时候才能被唤醒
static final int CONDITION = -2;
//传播节点
static final int PROPAGATE = -3;
//以上都是waitStatus的值，还有一个初始化0值；所以该值相当于当前线程的状态
volatile int waitStatus;
//前驱节点
volatile Node prev;
//后继节点
volatile Node next;
//该节点的线程
volatile Thread thread;
//下一个等待节点
Node nextWaiter;
}几个方法：
//分析一下独享锁上锁过程：
//acquire函数：获取独享锁的*入口！
public final void acquire(int arg) {
if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
//acquire函数--》tryAcquire函数：获取锁的函数，受保护的方法，此框架实现类只需重写该方法，定义获取锁的方式即可。
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
//acquire函数--》addWaiter函数：获取锁失败则加入CLH队列中去等待唤醒。
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)) {
//CAS设置tail到当前节点
pred.next = node;//设置后继节点为当前节点
return node;
}
}
//多线程插入失败则进入enq函数
enq(node);
return node;
}
//addWaiter函数--》enq函数：For CAS插入队尾
private Node enq(final Node node) {
//又是一个循环CAS操作
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;
}
}
}
}
//acquire函数--》acquireQueued函数：尝试去获取锁
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))//如果p==head说明当前节点是等待队列的第二个节点并尝试获取锁 {
//将当前设置为头节点
setHead(node);
//出列!把关联的下一个节点置空帮助垃圾回收
p.next = null; // help GC
failed = false;
return interrupted;
}
//找到安全的休息点休息并尝试拿锁
if(shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())
interrupted = true;
}
} finally {
//如果当前线程没拿到资源，发生了中断啥的
if (failed)
//取消获取锁
cancelAcquire(node);
}
}
//上完锁，来看看独享锁释放锁过程：
//release函数：释放独享锁的*入口！根据tryRelease函数的返回值来判断是否释放成功。
public final boolean release(long arg) {
if (tryRelease(arg)) {
//获取头节点
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
//release函数--》tryRelease函数：释放锁的函数，受保护的方法，此框架实现类只需重写该方法，定义获取锁的方式即可。
protected boolean tryRelease(long arg) {
throw new UnsupportedOperationException();
}
//release函数--》unparkSuccessor函数：唤醒下一个等待线程，FIFO，即唤醒最后一个线程！
private void unparkSuccessor(Node 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;
//拿到tail并唤醒
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
//唤醒！
if (s != null)
LockSupport.unpark(s.thread);
}
//tips:该抽象类中还使用了LockSupport类（阻塞原语），来阻塞线程和唤醒线程小结：AQS框架维护好了如何入队和出队，至于如何获取锁还需具体的实现类去定义，具体操作是，重写tryRelease和tryAcquire两个方法。
接下来我们看看，AQS框架里面的ConditionObject类：
public class ConditionObject implements Condition, java.io.Serializable {
private static final long serialVersionUID = 1173984872572414699L;
几个变量：
/** First node of condition queue. */
//维护一个队列的头节点
private transient Node firstWaiter;
/** Last node of condition queue. */
//尾节点
private transient Node lastWaiter;
/**
* Creates a new {@code ConditionObject} instance.
*/
public ConditionObject() { }
内置几个方法：
//让线程进入挂起状态，await函数是可响应中断的，还有其他的挂起方法，awaitUninterruptibly函数不响应中断，awaitNanos限时等
public final void await() throws InterruptedException {
//判断线程是否被中断
if (Thread.interrupted())
throw new InterruptedException();
//加入等待队列
Node node = addConditionWaiter();
//释放当前线程持有的锁并返回线程的state上文有说明
int savedState = fullyRelease(node);
//线程中断标记
int interruptMode = 0;
//循环判断该节点是否加入了AQS队列中
while (!isOnSyncQueue(node)) {
//不给线程通行证
LockSupport.park(this);
//循环判断是否被中断
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
//一旦被加入AQS队列中则，开始竞争获取锁
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
//清理不是在等待的节点
if (node.nextWaiter != null) // clean up if cancelled
unlinkCancelledWaiters();
//如果出现中断则抛出异常
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
//唤醒等待队列头
public final void signal() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignal(first);
}
}
//唤醒等待队列所有
public final void signalAll() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignalAll(first);
}