AQS原理解析

@[TOC]

1. AQS介绍

AQS 的全程为（AbstractQueuedSynchronizer）这个类在 java.util.concurrent.locks 包下

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable

AQS 是一个提供用于实现阻塞锁和同步器框架，依靠先入先出（FIFO）等待队列，该队列就是 CLH 同步队列，遵循 FIFO 原则 ,比如我们提到的 ReentrantLock ， ReentranSemaphoretLock ，其他的诸如 ReentrantReadWriteLock ， SynchronousQueue ， FutureTask(jdk1.7) ，等等皆是基于 AQS 的。当然，我们自己也能利用 AQS 非常轻松容易地构造出符合我们自己需求的同步器。

2. AQS原理

AQS 核心思想，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及唤醒锁时分配机制，这个机制 AQS 是用 CLH 队列锁实现的，即将暂时获取不到的锁加入到队列中。

CLH (Craig,Landin,and Hagersten) 队列是一个虚拟双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。原生的 CLH 队列适用于自旋锁，但 Doug Lea 把其改成阻塞锁，AQS 是将每条请求共享资源的线程封装成一个 CLH 锁队列的一个结点（Node）来实现锁的分配

在这里插入图片描述

AQS 使用来一个 int 成员变量来标识同步状态，通过内置但 FIFO 队列来完成获取资源线程但排队工作。


private volatile int state;



protected final int getState() {
        return state;
}

    
protected final void setState(int newState) {
       state = newState;
}

AQS 定义两种资源共享方式

Exclusive （独占）只有一个线程能执行，如 ReentrantLock

Share（共享）多个线程可以同时执行，如 Semaphore / CountDownLatCh 等

3. 源码分析

AQS 模版方法模式

同步器的设计是基于模版方法模式的，如果需要自定义同步器一般的方式

使用者继承 AbstractQueuedSynchronizer 并重写指定的方法，对于共享资源 state 的获取和释放
将 AQS 组合在自定义同步组件的实现中，并调用其模版方法，这些模版方法会调用使用者重写的方法

模版方法模式传送门： 模版方法模式

AQS 使用了模板方法模式，自定义同步器时需要重写下面几个 AQS 提供的模板方法：

sHeldExclusively() //该线程是否正在独占资源。只有用到condition才需要去实现它。

 tryAcquire(int) //独占方式。尝试获取资源，成功则返回true，失败则返回false。

 tryRelease(int) //独占方式。尝试释放资源，成功则返回true，失败则返回false。

 tryAcquireShared(int) //共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。

 tryReleaseShared(int) //共享方式。尝试释放资源，成功则返回true，失败则返回false。

以 ReentranLock 为例，state 初始化为 0 ，表示未锁状态，A线程 lock() 时，会调用 tryAcquire() 独占并将 state +1 。此后，其他线程再 tryAcquire() 时就会失败，直到A线程 unlock() 到 state = 0 (即释放锁) 为止，其他线程才有机会获取该锁。当然释放锁之前，A线程自己是可以重复获取此锁的（state会累加），者就是可重入的概念，但要注意，获取多少次就要释放多少次，这样才能保证 state 能回到 0 的状态。

一般来说，自定义同步器要么是独占方法，要么是共享方式，他们也只需实现 ==tryAcquire-tryRelease==、==tryAcquireShared-tryReleaseShared==中的一种即可。但AQS也支持自定义同步器同时实现独占和共享两种方式，如ReentrantReadWriteLock。

加锁（独占锁）

以 ReentranLock 为例 ReentranLock 锁 lock 方法源码 (非公平锁的实现 )

static final class NonfairSync extends Sync {

        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            // CAS 抢锁 修改 state值
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

AQS内部 acquire() 方法



public final void acquire(int arg) {
        if (!tryAcquire(arg)  // tryAcquire 由子类重写
            &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

tryAcquire 方法由子类重写，tryAcquire方法先尝试获取独占锁，获取成功则返回（非公平锁的体现）。
addWaiter 方法是 tryAcquire 返回 false 以后，也就是获取锁失败以后，就会把当前线程封装成Node,并添加到队列到尾部，并返回 Node 节点。
acquireQueued 负责把 addWaiter 返回的 Node 节点添加到队列结尾，并会执行获取锁操作以及判断是否把当前线程挂起。
selfInterrupt 是 AQS 中的 Thread.currentThread().interrupt() 方法调用，它的主要作用是执行完 acquire 之前自己执行中断操作

ReentranLock 子类重写 tryAcquire() 方法

 protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
}

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) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

如果 c == 0 说明没有线程正在竞争该锁，通过 CAS 方式获取锁，并返回 true
如果 current == getExclusiveOwnerThread() 也就是当前线程持有锁，只是简单但 ++acquires，并修改 status值，进行锁重入，但因为没有竞争，所以通过 setStatus 修改。

AQS内部 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) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

addWaiter 方法负责把当前无法获得锁的线程包装为一个 Node 添加到队尾（因为先进先出，所以添加到队尾）
如果当前队尾已经存在（tail != null）, 则使用 CAS 把当前线程更新为 tail
CAS 不一定一定成功，因为在并发场景下，可能会出现操作失败，则需要调用 enq 方法，该方法会自旋操作，把节点入队列

AQS内部 enq() 方法

private Node enq(final Node node) {
        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;
                }
            }
        }
    }

自旋 for 循环 + CAS 入队列。
当队列为空时，则会新创建一个节点，把尾节点指向头节点，然后继续循环。
第二次循环时，则会把当前线程当节点添加到队尾。

AQS内部 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);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

使用无限循环，如果 p == head && tryAcquire(arg) 条件不满足循环将永远无法结束，不会出现死循环，在于 parkAndCheckInterrupt() 方法会把当前线程挂起，从而阻塞住线程的调用栈。

private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

LockSupport.park 最终把线程交给系统 (Linux) 内核进行阻塞。也不是马上把请求不到锁的线程进行阻塞，而是检查该线程的状态，具体的检查在 shouldParkAfterFailedAcquire 中

AQS内部状态 waitStatus

static final int CANCELLED = 1 // 取消排队，放弃获取锁

 static final int SIGNAL = -1 // 表示后继结点在等待当前结点唤醒

 static final int CONDITION = -2 // 表示结点等待在Condition上，当其他线程调用了Condition的signal()方法后，CONDITION状态的结点将从等待队列转移到同步队列中，等待获取同步锁。

 static final int PROPAGATE = -3 共享模式下，前继结点不仅会唤醒其后继结点，同时也可能会唤醒后继的后继结点。

AQS内部 shouldParkAfterFailedAcquire() 方法

private 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;
    }

如果前继节点状态为 SIGNAL ，表明当前节点需要 unpark , 则成功返回，此时 acquireQueued 的parkAndCheckInterrupt 方法会将线程阻塞
如果前继节点的状态为 CANCELLED(ws>0)，说明前置节点已经被放弃，则回溯到一个非取消的前继节点，返回false ，acquireQueued 方法的无限循环将递归调用该方法，直至前继节点状态为 SIGNAL 返回 true，导致线程阻塞
如果前驱正常，那就把前驱的状态设置成SIGNAL，告诉它拿完后通知自己一下。

释放锁（独占锁）

public void unlock() {
        sync.release(1);
    }

AQS内部 release()方法

public final boolean release(int arg) {
        // tryRelease 判断释放释放资源 子类重写
        if (tryRelease(arg)) {
            Node h = head;
            // h.waitStatus ！= 0 表示候机节点在等待唤醒
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

release() 方法，在独占模式下线程释放资源的顶层接口，他会释放指定量的资源

ReentranLock 子类重写 tryRelease() 方法

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;
        }

Thread.currentThread() != getExclusiveOwnerThread() 判断是否为当前线程在调用，不是抛出 IllegalMonitorStateException异常
如果 c ==0 释放该锁，同时将当前锁持有线程设置为 null
setState(c) 设置 state 值

AQS内部 unparkSuccessor()

private void unparkSuccessor(Node node) {
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        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);
    }

如果 ws < 0 则利用 CAS 将当前节点清零
如果 s == null || s.waitStatus > 0 获取后继线程
如果 s != null 使用 LockSupport.unpark(s.thread) 唤醒后继线程

加锁（共享锁）

以 Semaphore 为例 Semaphore 共享锁使用 传送门： Semaphore信号量


Semaphore semaphore = new Semaphore(2, false);


public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

默认情况下只需要传入 permits 许可证数量即可，也就是一次允许放行几个线程，构造会通过 true / false 的方式实现公平锁，非公平锁

初始许可证数量：

NonfairSync(int permits) {
            super(permits);
        }

FairSync(int permits) {
            super(permits);
        }


Sync(int permits) {
            setState(permits);
        }

protected final void setState(int newState) {
        state = newState;
    }

在构造函数初始化的时候，无论是公平锁还是非公平锁，都会设置 AQS 中 state 数量值。这个值也就是为了下文中可以获取的信号量扣减和增加的值。

acquire() 方法

Semaphore semaphore = new Semaphore(2,false);
semaphore.acquire();


public void acquire() throws InterruptedException {
        // 调用 AQS内部的方法
        sync.acquireSharedInterruptibly(1);
    }

AQS内部 acquireSharedInterruptibly() 方法

public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
         // 判断线程是否中止
        if (Thread.interrupted())
            throw new InterruptedException();
          // tryAcquireShared 方法实现如下
        if (tryAcquireShared(arg) < 0)
            // doAcquireSharedInterruptibly 方法实现如下
            doAcquireSharedInterruptibly(arg);
    }

Semaphore 子类重写 tryAcquireShared 方法 (公平锁 )

static final class FairSync extends Sync {
        private static final long serialVersionUID = 2014338818796000944L;

        FairSync(int permits) {
            super(permits);
        }
        // 重写 AQS tryAcquireShared() 方法
        protected int tryAcquireShared(int acquires) {
            for (;;) {
                if (hasQueuedPredecessors())
                    return -1;
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }
    }

tryAcquireShared ，共享方式尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
hasQueuedPredecessors 公平锁的主要实现方法，它的目的就是判断有线程排在自己前面没，以及把线程添加到队列中逻辑实现。
for 自旋的过程，通过 CAS 来设置 state 偏移量对应值，这样就可以避免多线程下竞争获取信号量的冲突。
getState()，在构造函数中已经初始化 state 值，在这里获取信号量时就是使用 CAS 不断的扣减。

AQS内部 doAcquireSharedInterruptibly 方法实现

private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        // SHARED 起到标记作用，用于判断是否共享
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    // tryAcquireShared 用来获取同步状态 
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

首先 doAcquireSharedInterruptibly 方法来自于 AQS 内部方法。
for 自旋如果 p == head 在进行 tryAcquireShared 判断线程是否获取到锁。
如果 r > 0 setHeadAndPropagate(node, r)，同步成功后将当前线程设置为头节点，同时 helpGC ，p.next = null，断链操作。
shouldParkAfterFailedAcquire(p, node)，调整同步队列中 node 结点的状态，并判断是否应该被挂起。
parkAndCheckInterrupt()，判断是否需要被中断，如果中断直接抛出异常，当前结点请求也就结束。
cancelAcquire(node)，取消该节点的线程请求。

释放锁（共享锁）

public void release(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        sync.releaseShared(permits);
    }

调用 release 释放资源

AQS内部 releaseShared 方法

public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

tryReleaseShared 尝试获取资源

protected final boolean tryReleaseShared(int releases) {
            for (;;) {
                int current = getState();
                int next = current + releases;
                if (next < current) // overflow
                    throw new Error("Maximum permit count exceeded");
                if (compareAndSetState(current, next))
                    return true;
            }
        }

getState() 获取当前资源状态
如果 next < current 为是负数的话 , 则返回错误否则通过 CAS 操作设置 state 变量

AQS内部 doReleaseShared 方法

private void doReleaseShared() {
        
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }

如果 h != null && h != tail 头节点不为空并且头节点不是尾节点，则队列中有节点
h.waitStatus 判断当前 waitStatus 如果当前节点为 SIGNAL 将h节点的 waitStatus 设置成0失败 , 则 CAS 自旋设置直到成功
unparkSuccessor(h) 开始 unpark 前驱节点
如果 ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE) 如果 waitStatus 为0的话 , 则 CAS 设置PROPAGATE 继续下次循环
如果 h == head 头节点相同则break , 否则一直循环

个人博客地址：http://blog.yanxiaolong.cn ｜ 『纵有疾风起，人生不言弃』

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 213,254评论 6赞 492
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,875评论 3赞 387
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 158,682评论 0赞 348
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,896评论 1赞 285
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 66,015评论 6赞 385
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 50,152评论 1赞 291
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,208评论 3赞 412
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,962评论 0赞 268
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,388评论 1赞 304
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,700评论 2赞 327
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,867评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,551评论 4赞 335
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,186评论 3赞 317
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,901评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,142评论 1赞 267
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,689评论 2赞 362
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,757评论 2赞 351

AQS原理解析

1. AQS介绍

2. AQS原理

3. 源码分析

AQS 模版方法模式

加锁 （独占锁 ）

释放锁 （独占锁 ）

加锁 （共享锁）

释放锁 （共享锁）

推荐阅读更多精彩内容

加锁（独占锁）

释放锁（独占锁）

加锁（共享锁）

释放锁（共享锁）