AbstractQueuedSynchronizer源码解读

作者 : 开心源码 本文共4034个字,预计阅读时间需要11分钟 发布时间: 2022-05-12 共161人阅读

?? AbstractQueuedSynchronizer(AQS),是 Java 并发包中,实现各种同步结构和部分其余组成单元(如线程池中的 Worker)的基础。AQS 内部数据和方法,可以简单拆分为:

  • 一个 volatile 的整数成员表征状态(state属性),同时提供了 setState 和 getState 方法。
    1: ReentrantLock: 使用state变量记录某个线程获取独占锁的次数,获取锁时+1,释放锁时-1,在获取时会校验线程能否可以获取锁。
    2:Semaphore: 使用state变量作为计数器,只有在大于0时允许线程进入。获取锁时-1,释放锁时+1。
    3: CountDownLatch: 使用state变量作为计数器,在初始化时指定。只需state还大于0,获取共享锁会由于失败而阻塞,直到计数器的值为0时,共享锁才允许获取,所有等待线程会被逐一唤醒。
  • 一个先入先出(FIFO)的等待线程队列,以实现多线程间竞争和等待,这是 AQS 机制的核心之一。
  • 各种基于 CAS 的基础操作方法,以及各种期望具体同步结构去实现的 acquire/release 方法。

    AbstractQueuedSynchronizer关键属性

下面来看看acquire获取锁的部分源码:

public abstract class AbstractQueuedSynchronizer    extends AbstractOwnableSynchronizer    implements java.io.Serializable {//定义为final说明子类不能覆盖这个实现过程    public final void acquire(int arg) {//这里分别会调使用tryAcquire方法使用于获取锁,假如失败,会调使用addWaiter方法,将当前线的Node加入到FIFO队列里,通过acquireQueued判断当前节点能否为头节点,假如是则试图获取锁,假如不是,则进行等待。        if (!tryAcquire(arg) &&            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))            selfInterrupt();    }//这个方法在AbstractQueuedSynchronizer里留给子类来实现,    protected boolean tryAcquire(int arg) {        throw new UnsupportedOperationException();    }}

这里分别会调使用tryAcquire方法使用于获取锁,假如失败,会调使用addWaiter方法,将当前线的Node加入到FIFO队列里,通过acquireQueued判断当前节点能否为头节点,假如是则试图获取锁,假如不是,则进行等待。在AbstractQueuedSynchronizer里tryAcquire方法是留给子类来实现的,下面来看看ReentrantLock里的非公平锁是如何实现这里的逻辑的。源码如下:

abstract static class Sync extends AbstractQueuedSynchronizer {      //非公平锁最终最调使用到当前这个方法,传入的acquires为1    final boolean nonfairTryAcquire(int acquires) {        final Thread current = Thread.currentThread();         int c = getState();// 获取当前 AQS 内部状态量          if (c == 0) { // 0 表示无人占有,则直接使用 CAS 修改状态位,                if (compareAndSetState(0, acquires)) {// 不检查排队情况,直接争抢                      setExclusiveOwnerThread(current);  // 并设置当前线程独占锁                    return true;                }          } else if (current == getExclusiveOwnerThread()) { // 即便状态不是 0,也可能当前线程是锁持有者,由于这是再入锁                int nextc = c + acquires;                  if (nextc < 0) // overflow                throw new Error("Maximum lock count exceeded");                setState(nextc);                return true;    }    return false;}}

ReentrantLock的公平锁的实现逻辑如下:

   static final class FairSync extends Sync {//公平锁的实现逻辑        protected final boolean tryAcquire(int acquires) {            final Thread current = Thread.currentThread();            int c = getState();// 获取当前 AQS 内部状态量            if (c == 0) {// 0 表示无人占有,                if (!hasQueuedPredecessors() && //这里需要判断队列头节点的的下一个节点为空。也就是说不允许线程进行插队。                    compareAndSetState(0, acquires)) { //为空才会尝试获取锁                    setExclusiveOwnerThread(current);                    return true;                }            }            else if (current == getExclusiveOwnerThread()) { // 即便状态不是 0,也可能当前线程是锁持有者,由于这是再入锁                int nextc = c + acquires;                if (nextc < 0)                    throw new Error("Maximum lock count exceeded");                setState(nextc);                return true;            }            return false;        }    }

接下来再分析 acquireQueued,假如前面的 tryAcquire 失败,代表着锁争抢失败,进入排队竞争阶段。这里就是利使用 FIFO 队列,实现线程间对锁的竞争的部分,算是是 AQS 的核心逻辑。源码如下:

//这个方法是不允许子类重写的    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)) { / 假如前一个节点是头结点,则当前节点是FIFO队列里的第一个节点,则会再次调使用tryAcquire方法尝试获取锁。                    setHead(node); //成功,则设置当前节点为头节点                    p.next = null; // help GC 清空前面节点对当前节点的引使用                    failed = false;                    return interrupted;                }                if (shouldParkAfterFailedAcquire(p, node) && //失败后需要调使用park                    parkAndCheckInterrupt())                    interrupted = true;            }        } finally {            if (failed) // 获取锁失败,调使用cancelAcquire方法                cancelAcquire(node);        }    }

acquireQueued 的逻辑,简要来说,就是假如当前节点的前面是头节点,则试图获取锁,一切顺利则成为新的头节点;否则,有必要则等待。上面的部分分析了获取锁的逻辑。下面再来看看释放锁的逻辑AbstractQueuedSynchronizer的relase源码如下:

//释放锁需要调使用release方法    public final boolean release(int arg) {        if (tryRelease(arg)) {//释放成功后,调使用unparkSuccessor方法,让下个节点得到锁            Node h = head;            if (h != null && h.waitStatus != 0)                unparkSuccessor(h);            return true;        }        //留给具体的子类来实现    protected boolean tryRelease(int arg) {        throw new UnsupportedOperationException();    }//当前节点释放锁,下个节点得到锁状态     private void unparkSuccessor(Node node) {        int ws = node.waitStatus;//设置当前节点的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;        }//下一个节点不为空,则调使用LockSupport的unpark方法唤醒线程        if (s != null)            LockSupport.unpark(s.thread);    }

ReentrantLock里tryRelease的实现如下所示:

        protected final boolean tryRelease(int releases) {            int c = getState() - releases; //使用state减去release, 这个状态是新的状态             if (Thread.currentThread() != getExclusiveOwnerThread())                throw new IllegalMonitorStateException();            boolean free = false; //释放的结果使用free来表示            if (c == 0) { //为零,表求当前没有钱程点使用了,                free = true;                setExclusiveOwnerThread(null);            }  //设置状态             setState(c);            return free;        }

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » AbstractQueuedSynchronizer源码解读

发表回复