概述

aqs是java并发包的一个基石级别服务，主要是通过队列和大量的cas来玩转。本文我们会基于公平锁来跟进

大致流程图，如下 后面会详细的跟下代码

抢锁流程

后续补个图，这个是公平锁的lock方法。ReentraLock的内部类 FairSync类关系 FairSync extend Sync（抽象类） extends AbstractQueuedSynchronizer
sync定义了lock抽象方法给 子类实现，FairSync的实现具体是依赖 aqs的 acquire来看下acquire方法【这是个小模版方法，具体实现还是各类自己实现】
tryAcquire和acquireQueued都会尝试抢锁
public final void acquire(int arg) {if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();
}代码也比较简单，前面没有排队的就cas抢锁。如果有线程持有锁，正好那个线程就是自己statue+1protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();//0表示没有线程持有锁if (c == 0) {//如果前面没有节点 就来一次cas 成功了 把当前线程设置成独占线程if (!hasQueuedPredecessors() &&compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}//这个看持有锁的线程是否是自己，如果是的，在进一次 就是可重入的实现else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0)throw new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}再看下入队逻辑    private Node addWaiter(Node mode) {Node node = new Node(Thread.currentThread(), mode);// Try the fast path of enq; backup to full enq on failureNode pred = tail;if (pred != null) {node.prev = pred;if (compareAndSetTail(pred, node)) {pred.next = node;return node;}}enq(node);return node;}如果队列为空enq，看下初始化代码 注意下header节点是个空的，里面没有线程
先初始化链表，再把自己设置成tail节点private Node enq(final Node node) {for (;;) {Node t = tail;if (t == null) { // Must initializeif (compareAndSetHead(new Node()))tail = head;} else {node.prev = t;if (compareAndSetTail(t, node)) {t.next = node;return t;}}}}//第二次抢锁，前继节点是head节点 就会尝试抢一次。
//第一次抢锁成功返回false，如果第一次阻塞自己，第二次再抢锁成功 返回true
代表是否被interrupted过
抢锁失败，把自己的前面那个节点的waitStatue设置成-1，阻塞当前线程
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 GCfailed = false;return interrupted;}//把前继节点的signal设置成-1，同时清理阻塞队列中取消等待的节点//第二个函数很简单 就是park自己 同时返回中断状态if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}}//是否需要阻塞，这个函数主要是把前面那个节点waitStatus改成-1，
如果前面的节点状态是取消，把他从队列里面剔除。
这个一般会执行两次，第二次才会是trueprivate 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;}//上面是否需要阻塞，主要就是剔除取消节点和把前面节点的waitStatue改成-1
//准备工作做好了，把自己阻塞起来 等待唤醒 [中断和释放锁的动作会释放park]private final boolean parkAndCheckInterrupt() {LockSupport.park(this);return Thread.interrupted();}

释放锁

    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;}//判断当前线程是否是持有锁的线程，如果statue=0（代表完全释放了） 把当前支持的锁的线程设置为空protected final boolean tryRelease(int releases) {int c = getState() - releases;if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();boolean free = false;if (c == 0) {free = true;setExclusiveOwnerThread(null);}setState(c);return free;}//如果锁释放干净了，先把head的waitStatus设置为0，通知后面等待的兄弟们 起来拿锁
//拿锁有两个动作 
如果同步队列里面第一把交椅还活着（不算header），直接唤醒这个对应的线程
如果不存在，之前代码会经常把next=null（帮助gc），只能从tail往前遍历第一个waitStatus<=0的
（代表没有放弃等待的节点，效率不是很高，其实同步队列一般也没那么长）private void unparkSuccessor(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;for (Node t = tail; t != null && t != node; t = t.prev)if (t.waitStatus <= 0)s = t;}if (s != null)LockSupport.unpark(s.thread);}

node结构

这个其实就是包装了请求的线程，记录了前后节点，争抢状态，模式-独占/共享

public 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;//上面四个就是给他用的int waitStatus;Node prev;Node next;//节点里面的线程Thread thread;
}

公平与非公平的差异

主要差异在抢锁会判断有没有前继节点，非公平直接来个cas 不上路子的操作（有两个地方会尝试直接抢锁 下面代码有标注），吞吐量会好一些，不过可能会造成之前排队中的线程产生长时间的饥饿等待。

ReeranterLock默认就是非公平

        final void lock() {
//第一次-先直接cas抢一次if (compareAndSetState(0, 1))setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);}public final void acquire(int arg) {if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}final boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {
//第二次-这里也不看是否是有前继节点if (compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}

条件队列

大致处理流程图

todo

流程代码

简单使用demo

Lock lock = new ReentrantLock();
//每个condition都会有一个对应的条件队列
Condition condition = lock.newCondition();
lock.lock();
业务代码
//阻塞业务执行线程
condition.await();唤醒阻塞线程-同步队列中的头节点
lock.lock();
condition.signal();

AWAIT|SIGNAL-细节代码

        public final void await() throws InterruptedException {
//响应中断            
if (Thread.interrupted())throw new InterruptedException();
//进入条件队列（单向链表）把自己加入到队尾 同时会把所有取消的节点清除出队列Node node = addConditionWaiter();
//释放所有的锁，同时记录下 之前持有的锁记录[被唤醒后会重新获取锁]
//这里顺带说一句 和wait notify有点类似，如果当前线程不持有锁，直接await会直接报错 IllegalMonitorStateExceptionint savedState = fullyRelease(node);int interruptMode = 0;
//如果没有进入阻塞队列，把自己挂起来 =====while开始while (!isOnSyncQueue(node)) {
//这里就告一段落了，自己进入了队尾，清理了条件队列，把自己挂起来了
[有线程来signal操作-加入阻塞队列 前继节点取消了或者更新前继节点waitStatus=-1失败
|对该线程做了中断操作 可能会唤醒他]LockSupport.park(this);
//下面这个方法的意思是发生过中断 跳出循环
//interruptMode的逻辑如下  awaitStatus=0是个分水岭
//如果不是中断状态的是0
//如果在别的线程signal前被中断的是THROW_IE （根据waitStatus！=0来识别的）
//如果在waitStatus=0 但是不在阻塞队列中 这个时候会一直自旋 直到进入阻塞队列 REINTERRUPT
//Thread.interrupted?(transferAfterCancelledWait(node)？THROW_IE:REINTERRUPT):0//附上李大爷的注释 清晰明了
//如果是signal之前中断的Throw_IE 如果是在之后REINTERRUPT
Checks for interrupt, returning THROW_IE if interrupted* before signalled, REINTERRUPT if after signalled, or* 0 if not interrupted.if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)break;}
} //===========while结束
//如果在阻塞队列中抢锁成功，并且中断模式！=-1 把这个中断模式设置成1
//两种情况1-正常进入到阻塞队列中 或者在signal之后被中断的 if (acquireQueued(node, savedState) && interruptMode != THROW_IE)interruptMode = REINTERRUPT;
//这里一定都到了阻塞队列中了，和条件队列中的小兄弟断绝关系if (node.nextWaiter != null) // clean up if cancelledunlinkCancelledWaiters();
//发生了中断，这里统一处理if (interruptMode != 0)reportInterruptAfterWait(interruptMode);}//如果await期间，signal之前被中断 抛中断异常
//如果是signal之后被中断的，自己调用一次中断
注意第二个场景 如果在signal前被中断 但是抢锁成功了也走Throw_ie逻辑
private void reportInterruptAfterWait(int interruptMode)throws InterruptedException {if (interruptMode == THROW_IE)throw new InterruptedException();else if (interruptMode == REINTERRUPT)selfInterrupt();}

//从条件队列里面唤醒节点，依此头节点到后面。成功了就返回
//具体就是把对应节点waitStatus设置成0，enQ。如果前继节点取消了等待或者更新前继节点waitStatus=-1失败，换新node对应的线程
public final void signal() {if (!isHeldExclusively())throw new IllegalMonitorStateException();Node first = firstWaiter;if (first != null)doSignal(first);
}//从第一个开始唤醒，如果失败 尝试唤醒第二个 依此类推private void doSignal(Node first) {do {if ( (firstWaiter = first.nextWaiter) == null)lastWaiter = null;first.nextWaiter = null;} while (!transferForSignal(first) && (first = firstWaiter) != null);}//把条件队列里面的node搞到阻塞队列中，先把waitStatus设置成0，然后加入队尾
//如果前继节点的waitStatus>0 说明取消了，或者把前节点更新成-1失败 唤醒node对应的线程final boolean transferForSignal(Node node) {if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))return false;Node p = enq(node);
//这个一般是0int ws = p.waitStatus;if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))LockSupport.unpark(node.thread);return true;}