一、概述
AQS全称 AbstractQueuedSynchronizer 抽象队列同步器，java concurrent包里很多类中定义了Sync内部类继承自AQS,比如 ReentrantLock，CountDownLatch，Semaphore，CyclicBarrier（内部使用了ReentrantLock）等，下面我们来通过ReentrantLock源码解读AQS
二、AQS内部框架
1.定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）
2.定义了一个volatile int state，0代表空闲状态，1代表占用状态
3.定义了一个Node节点
static final class Node {
static final Node SHARED = new Node();
static final Node EXCLUSIVE = null;
//表示当前结点已取消调度。当timeout或被中断（响应中断的情况下），会触发变更为此状态，进入该状态后的结点将不会再变化。
static final int CANCELLED = 1;
//表示后继结点在等待当前结点唤醒。后继结点入队时，会将前继结点的状态更新为SIGNAL
static final int SIGNAL = -1;
//表示结点等待在Condition上，当其他线程调用了Condition的signal()方法后，CONDITION状态的结点将从等待队列转移到同步队列中，等待获取同步锁
static final int CONDITION = -2;
//共享模式下，前继结点不仅会唤醒其后继结点，同时也可能会唤醒后继的后继结点
static final int PROPAGATE = -3;
volatile int waitStatus;//节点的状态1,0,-1,-2,-3
volatile Node prev;//前驱
volatile Node next;//后驱
volatile Thread thread;//节点的所属线程
Node nextWaiter;
.....
}
4.定义了4个方法必须子类实现否则抛出异常
- tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。
- tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。
- tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
- tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。
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 isHeldExclusively() {
throw new UnsupportedOperationException();
}
三、源码解读
我们以银行窗口办理业务为例，定义三个线程A,B,C，只有一个窗口，首先A线程抢占锁，我们以非公平锁为例
初始状态：state=0,Thread=null
ReentrantLock lock = new ReentrantLock();
new Thread(()->{
lock.lock();
try {
System.out.println("A thread come in ---------");
TimeUnit.MINUTES.sleep(20);
}catch (Exception e){
}finally {
lock.unlock();
}
},"A").start();
new Thread(()->{
lock.lock();
try {
System.out.println("B thread come in ---------");
}catch (Exception e){
}finally {
lock.unlock();
}
},"B").start();
new Thread(()->{
lock.lock();
try {
System.out.println("C thread come in ---------");
}catch (Exception e){
}finally {
lock.unlock();
}
},"C").start();
1.LOCK
进入lock()方法（AQS非公平锁的实现类中）
ReentrantLock.java
final void lock() {
if (compareAndSetState(0, 1))//cas设置state状态为1
setExclusiveOwnerThread(Thread.currentThread());//设置当前线程为A
else
acquire(1);//上面设置状态失败尝试获取锁
}
A线程sleep 20分钟，此时B线程或C线程进入获取锁执行 上面代码 的 acquire(1);方法
AbstractQueuedSynchronizer .java
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
这里重要的有三个方法：
- tryAcquire(arg)：尝试获取锁
- addWaiter(Node.EXCLUSIVE)：添加到同步队列
- acquireQueued(addWaiter(Node.EXCLUSIVE), arg))：队列里自旋等待获取等
进入tryAcquire(arg)方法（AQS非公平锁的实现类中）
ReentrantLock.java
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();//当前B线程
int c = getState();//c=1
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {//重入锁进入
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
返回false,故!tryAcquire(arg)=true，下面进入AQS的addWaiter(Node.EXCLUSIVE)方法
AbstractQueuedSynchronizer .java
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);//new出B线程的Node
Node pred = tail;//存起尾节点
//尝试快速方式直接放到队尾。
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//上一步失败则通过enq入队
enq(node);
return node;
}
刚开始pred=null走enq(node);方法
private Node enq(final Node node) {
for (;;) {//自旋添加节点
Node t = tail;
if (t == null) { // 尾节点为空，new 一个哨兵节点state=0,Thread=null
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;//哨兵节点创建完，加入B加点到尾部
if (compareAndSetTail(t, node)) {
t.next = node;
return t;//返回 哨兵节点
}
}
}
}
enq(node)返回哨兵节点
回到addWaiter()方法,再返回B节点，acquireQueued(addWaiter(Node.EXCLUSIVE), arg))；方法
AbstractQueuedSynchronizer .java
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;//标记是否成功拿到资源
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();//前驱
//如果前驱是head，那么便尝试获取资源，可能是前一个释放完资源唤醒自己的，当然也可能被中断了
if (p == head && tryAcquire(arg)) {
setHead(node);//拿到资源后，将head指向该结点。所以head所指的标杆结点，就是当前获取到资源的那个结点或null
p.next = null;//setHead中node.prev已置为null，此处再将head.next置为null，就是为了方便GC回收以前的head结点。也就意味着之前拿完资源的结点出队了
failed = false;// 成功获取资源
return interrupted;//返回等待过程中是否被中断过
}
//如果自己可以休息了，就通过park()进入waiting状态，直到被unpark()。如果不可中断的情况下被中断了，那么会从park()中醒过来，发现拿不到资源，从而继续进入park()等待
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;//如果等待过程中被中断过，哪怕只有那么一次，就将interrupted标记为true
}
} finally {
// 如果等待过程中没有成功获取资源（如timeout，或者可中断的情况下被中断了），那么取消结点在队列中的等待
if (failed)
cancelAcquire(node);
}
}
node为B节点，故p为head,因此进入tryAcquire(arg),再次抢占由于A线程一直占用所以还是false，因此进入
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;分支
- shouldParkAfterFailedAcquire(p, node)
- parkAndCheckInterrupt()
进入shouldParkAfterFailedAcquire(p, node) 方法
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;//前驱的状态
if (ws == Node.SIGNAL)如果已经告诉前驱拿完号后通知自己一下，那就可以安心休息了
return true;
if (ws > 0) {
/*
* 如果前驱放弃了，那就一直往前找，直到找到最近一个正常等待的状态，并排在它的后边。
* 注意：那些放弃的结点，由于被自己“加塞”到它们前边，它们相当于形成一个无引用链，稍后就会被GC回收！
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
//如果前驱正常，那就把前驱的状态设置成SIGNAL，告诉它拿完号后通知自己一下
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
初始进入pred.waitStatus=0；进入 compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
设置状态为Node.SIGNAL（-1）
第二次循环return true,进入parkAndCheckInterrupt()方法
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);//线程被阻塞挂起，使线程进入waiting状态,等待被unpark
return Thread.interrupted();
}
B线程被阻塞挂起，使线程进入waiting状态，等待被unpark
同理C线程也如此
2.unlock
进入unlock()方法
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)//h为哨兵节点head,waitStatus为-1（SIGNAL）
unparkSuccessor(h);//unpark下一个线程
return true;
}
return false;
}
进入tryRelease(arg)方法
protected final boolean tryRelease(int releases) {
int c = getState() - releases;//c=1-1=0
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
c = 1-1=0 把当前占用的线程设置为null
回到release()方法，为哨兵节点部位null,waitStatus=-1,走unparkSuccessor(h)方法
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;//-1
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);//waitStatus=0
Node s = node.next;//哨兵节点head的下一个节点（B）
if (s == null || s.waitStatus > 0) {//s不为空，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);//唤醒线程
}
走compareAndSetWaitStatus(node, ws, 0);设置哨兵节点的waitStatus=0，哨兵节点head的下一个节点（B）不为空，/唤醒B线程
B线程继续在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)) {//抢占节点
setHead(node);//设置B为哨兵节点
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
node节点为B,p为前驱节点即head,B节点tryAcquire(arg)成功，state设置为1，Thread设置为B
完了之后设置原来的B为哨兵节点，删除原哨兵节点
置空线程
至此lock与unlock非公平锁讲解完毕
总结
使用AQS 自定义静态内部类Sync继承父类AbstractQueuedSynchronizer 继承它的 tryAcquire(int), tryRelease(int)，tryAcquireShared(int)，tryReleaseShared(int)
AQS重要方法
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
- tryAcquire(arg)
- addWaiter(Node.EXCLUSIVE)
- acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
- shouldParkAfterFailedAcquire(p, node)
- parkAndCheckInterrupt()
release中
- unparkSuccessor(Node node)
挂机线程，唤醒乘车 都是基于LockSupport来实现的，unpark单独使用，可以放在park前，并且许可证最多为1，连续调用两次unpark相当于只调了一次
共享模式分析请看下篇 结合AQS对CountDownLatch进行源码解读
86
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
