文档章节

聊聊并发(十三)—AQS框架深入分析

陶邦仁
 陶邦仁
发布于 2015/11/20 11:48
字数 3909
阅读 460
收藏 11

#0 系列目录#

#1 什么是同步器# 多线程并发的执行,之间通过某种 共享 状态来同步,只有当状态满足 xxxx 条件,才能触发线程执行 xxxx 。这个共同的语义可以称之为同步器。可以认为所有的锁机制都可以基于同步器定制来实现的

而juc(java.util.concurrent)里的思想是 将这些场景抽象出来的语义通过统一的同步框架来支持。juc 里所有的这些锁机制都是基于 AQS ( AbstractQueuedSynchronizer )框架上构建的。下面简单介绍下 AQS( AbstractQueuedSynchronizer )。

我们来看下java.util.concurrent.locks大致结构:

输入图片说明

上图中,LOCK的实现类其实都是构建在AbstractQueuedSynchronizer上,为何图中没有用UML线表示呢,这是每个Lock实现类都持有自己内部类Sync的实例,而这个Sync就是继承AbstractQueuedSynchronizer(AQS)。为何要实现不同的Sync呢?这和每种Lock用途相关。另外还有AQS的State机制。下文会举例说明不同同步器内的Sync与state实现。

#2 AQS框架如何构建同步器# ##2.1 同步器的基本功能## 一个同步器至少需要包含两个功能:

  1. 获取同步状态:如果允许,则获取锁,如果不允许就阻塞线程,直到同步状态允许获取。
  2. 释放同步状态:修改同步状态,并且唤醒等待线程。

根据作者论文, aqs 同步机制同时考虑了如下需求:

  1. 独占锁和共享锁两种机制
  2. 线程阻塞后,如果需要取消,需要支持中断
  3. 线程阻塞后,如果有超时要求,应该支持超时后中断的机制

##2.2 同步状态的获取与释放## AQS实现了一个同步器的基本结构,下面以独占锁与共享锁分开讨论,来说明AQS怎样实现获取、释放同步状态。

###2.2.1 独占模式### 独占获取: tryAcquire 本身不会阻塞线程,如果返回 true 成功就继续,如果返回 false 那么就阻塞线程并加入阻塞队列。

    public final void acquire(int arg) {  
  
        if (!tryAcquire(arg) &&  
  
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//获取失败,则加入等待队列  
  
            selfInterrupt();  
  
    }  

独占且可中断模式获取:支持中断取消

    public final void acquireInterruptibly(int arg) throws InterruptedException {  
  
        if (Thread.interrupted())  
            throw new InterruptedException();  
        if (!tryAcquire(arg))  
            doAcquireInterruptibly(arg);  

    }   

独占且支持超时模式获取: 带有超时时间,如果经过超时时间则会退出。

    public final boolean tryAcquireNanos(int arg, long nanosTimeout) throws InterruptedException {  
  
        if (Thread.interrupted())  
  
            throw new InterruptedException();  
  
        return tryAcquire(arg) || doAcquireNanos(arg, nanosTimeout);  
    }

独占模式释放:释放成功会唤醒后续节点

    public final boolean release(int arg) {  
        if (tryRelease(arg)) {  
            Node h = head;  
            if (h != null && h.waitStatus != 0)  
                unparkSuccessor(h);  
            return true;  
        }  
        return false;  
    }  

###2.2.2 共享模式### 共享模式获取

    public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);  
    }

可中断模式共享获取

    public final void acquireSharedInterruptibly(int arg) throws InterruptedException {  
        if (Thread.interrupted())  
            throw new InterruptedException();  
        if (tryAcquireShared(arg) < 0)  
            doAcquireSharedInterruptibly(arg);  
    }   

共享模式带定时获取

    public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException {  
        if (Thread.interrupted())  
            throw new InterruptedException();  
        return tryAcquireShared(arg) >= 0 ||  
            doAcquireSharedNanos(arg, nanosTimeout);  
    }   

共享锁释放

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

注意以上框架只定义了一个同步器的基本结构框架,基本方法里依赖的 tryAcquire 、 tryRelease 、tryAcquireShared 、 tryReleaseShared 四个方法在 AQS 里没有实现,这四个方法不会涉及线程阻塞,而是由各自不同的使用场景根据情况来定制:

    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 tryReleaseShared(int arg) {  
        throw new UnsupportedOperationException();
    }  

从以上源码可以看出AQS实现基本的功能: AQS虽然实现了acquire,和release方法是可能阻塞的,但是里面调用的tryAcquire和tryRelease是由子类来定制的且是不阻塞的。可以认为同步状态的维护、获取、释放动作是由子类实现的功能,而动作成功与否的后续行为时有AQS框架来实现

##2.3 状态获取、释放成功或失败的后续行为:线程的阻塞、唤醒机制## 有别于wait和notiry。这里利用 jdk1.5 开始提供的 LockSupport.park() 和 LockSupport.unpark() 的本地方法实现,实现线程的阻塞和唤醒

得到锁的线程禁用(park)和唤醒(unpark),也是直接native实现(这几个native方法的实现代码在hotspot\src\share\vm\prims\unsafe.cpp文件中,但是关键代码park的最终实现是和操作系统相关的,比如windows下实现是在os_windows.cpp中,有兴趣的同学可以下载jdk源码查看)。唤醒一个被park()线程主要手段包括以下几种:

  1. 其他线程调用以被park()线程为参数的unpark(Thread thread)。
  2. 其他线程中断被park()线程,如waiters.peek().interrupt();waiters为存储线程对象的队列。
  3. 不知原因的返回。

park()方法返回并不会报告到底是上诉哪种返回,所以返回后最好检查下线程状态,如:

    LockSupport.park();  // 禁用当前线程
    if(Thread.interrupted){
        //doSomething
    }

AbstractQueuedSynchronizer(AQS)对于这点实现得相当巧妙,如下所示:

    private void doAcquireSharedInterruptibly(int arg)throwsInterruptedException {  
        final Node node = addWaiter(Node.SHARED);  
        try {  
            for (;;) {  
                final Node p = node.predecessor();  
                if (p == head) {  
                    int r = tryAcquireShared(arg);  
                    if (r >= 0) {  
                        setHeadAndPropagate(node, r);  
                        p.next = null; // help GC  
                        return;  
                    }  
                }  
                //parkAndCheckInterrupt()会返回park住的线程在被unpark后的线程状态,如果线程中断,跳出循环。  
                if (shouldParkAfterFailedAcquire(p, node) &&  
                    parkAndCheckInterrupt())  
                    break;  
             }  
         } catch (RuntimeException ex) {  
             cancelAcquire(node);  
             throw ex;  
         }  
  
         // 只有线程被interrupt后才会走到这里  
         cancelAcquire(node);  
         throw new InterruptedException();  
    }  
  
    //在park()住的线程被unpark()后,第一时间返回当前线程是否被打断  
    private final boolean parkAndCheckInterrupt() {  
        LockSupport.park(this);  
        return Thread.interrupted();  
    }  

##2.4 线程阻塞队列的维护## 阻塞线程节点队列 CHL Node queue 。

根据论文里描述, AQS 里将阻塞线程封装到一个内部类 Node 里。并维护一个 CHL Node FIFO 队列CHL队列是一个非阻塞的 FIFO 队列,也就是说往里面插入或移除一个节点的时候,在并发条件下不会阻塞,而是通过自旋锁和 CAS 保证节点插入和移除的原子性。实现无锁且快速的插入。CHL队列对应代码如下:

    /** 
     * CHL头节点 
     */   
    private transient volatile Node head;
    /** 
     * CHL尾节点 
     */  
    private transient volatile Node tail;

Node节点是对Thread的一个封装,结构大概如下:

    static final class Node {  
        /** 代表线程已经被取消*/  
        static final int CANCELLED =  1;  
        /** 代表后续节点需要唤醒 */  
        static final int SIGNAL    = -1;  
        /** 代表线程在等待某一条件/ 
        static final int CONDITION = -2; 
        /** 标记是共享模式*/  
        static final Node SHARED = new Node();  
        /** 标记是独占模式*/  
        static final Node EXCLUSIVE = null;  
  
        /** 
         * 状态位 ,分别可以使CANCELLED、SINGNAL、CONDITION、0 
         */  
        volatile int waitStatus;  
  
        /** 
         * 前置节点 
         */  
        volatile Node prev;  
  
        /** 
         * 后续节点 
         */  
        volatile Node next;  
  
        /** 
         * 节点代表的线程 
         */  
        volatile Thread thread;  
  
        /** 
         *连接到等待condition的下一个节点 
         */  
        Node nextWaiter;
    }  

##2.5 小结## 从源码可以看出AQS实现基本的功能:

  1. 同步器基本范式、结构
  2. 线程的阻塞、唤醒机制
  3. 线程阻塞队列的维护

AQS虽然实现了acquire,和release方法,但是里面调用的tryAcquire和tryRelease是由子类来定制的。可以认为同步状态的维护、获取、释放动作是由子类实现的功能,而动作成功与否的后续行为时有AQS框架来实现,还有以下一些私有方法,用于辅助完成以上的功能:

final boolean acquireQueued(final Node node, int arg) :申请队列
private Node enq(final Node node) : 入队
private Node addWaiter(Node mode) :以mode创建创建节点,并加入到队列
private void unparkSuccessor(Node node) : 唤醒节点的后续节点,如果存在的话。
private void doReleaseShared() :释放共享锁
private void setHeadAndPropagate(Node node, int propagate):设置头,并且如果是共享模式且propagate大于0,则唤醒后续节点。
private void cancelAcquire(Node node) :取消正在获取的节点
private static void selfInterrupt() :自我中断
private final boolean parkAndCheckInterrupt() : park 并判断线程是否中断

#3 AQS在各同步器内的Sync与State实现# ##3.1 什么是state机制## 提供 volatile 变量 state; 用于同步线程之间的共享状态。通过 CAS 和 volatile 保证其原子性和可见性。对应源码里的定义:

/** 
 * 同步状态 
 */  
private volatile int state;  
  
/** 
 *cas 
 */  
protected final boolean compareAndSetState(int expect, int update) {  
    // See below for intrinsics setup to support this  
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);  
}  

##3.2 不同实现类的Sync与State## 基于AQS构建的Synchronizer包括ReentrantLock,Semaphore,CountDownLatch, ReetrantRead WriteLock,FutureTask等,这些Synchronizer实际上最基本的东西就是原子状态的获取和释放,只是条件不一样而已

###3.2.1 ReentrantLock### 需要记录当前线程获取原子状态的次数,如果次数为零,那么就说明这个线程放弃了锁(也有可能其他线程占据着锁从而需要等待),如果次数大于1,也就是获得了重进入的效果,而其他线程只能被park住,直到这个线程重进入锁次数变成0而释放原子状态。以下为ReetranLock的FairSync的tryAcquire实现代码解析。

//公平获取锁
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    //如果当前重进入数为0,说明有机会取得锁
    if (c == 0) {
        //如果是第一个等待者,并且设置重进入数成功,那么当前线程获得锁
        if (isFirst(current) &&
            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;
}

###3.2.2 Semaphore### 则是要记录当前还有多少次许可可以使用,到0,就需要等待,也就实现并发量的控制,Semaphore一开始设置许可数为1,实际上就是一把互斥锁。以下为Semaphore的FairSync实现:

protected int tryAcquireShared(int acquires) {
    Thread current = Thread.currentThread();
    for (;;) {
         Thread first = getFirstQueuedThread();
         //如果当前等待队列的第一个线程不是当前线程,那么就返回-1表示当前线程需要等待
         if (first != null && first != current)
              return -1;
         //如果当前队列没有等待者,或者当前线程就是等待队列第一个等待者,那么先取得semaphore还有几个许可证,并且减去当前线程需要的许可证得到剩下的值
         int available = getState();
         int remaining = available - acquires;
         //如果remining<0,那么反馈给AQS当前线程需要等待,如果remaining>0,并且设置availble成功设置成剩余数,那么返回剩余值(>0),也就告知AQS当前线程拿到许可,可以继续执行。
         if (remaining < 0 ||compareAndSetState(available, remaining))
             return remaining;
   }
}

###3.2.3 CountDownLatch### 闭锁则要保持其状态,在这个状态到达终止态之前,所有线程都会被park住,闭锁可以设定初始值,这个值的含义就是这个闭锁需要被countDown()几次,因为每次CountDown是sync.releaseShared(1),而一开始初始值为10的话,那么这个闭锁需要被countDown()十次,才能够将这个初始值减到0,从而释放原子状态,让等待的所有线程通过。

//await时候执行,只查看当前需要countDown数量减为0了,如果为0,说明可以继续执行,否则需要park住,等待countDown次数足够,并且unpark所有等待线程  
public int tryAcquireShared(int acquires) {  
     return getState() == 0? 1 : -1;  
}  
  
//countDown 时候执行,如果当前countDown数量为0,说明没有线程await,直接返回false而不需要唤醒park住线程,如果不为0,得到剩下需要 countDown的数量并且compareAndSet,最终返回剩下的countDown数量是否为0,供AQS判定是否释放所有await线程。  
public boolean tryReleaseShared(int releases) {  
    for (;;) {  
         int c = getState();  
         if (c == 0)  
             return false;  
         int nextc = c-1;  
         if (compareAndSetState(c, nextc))  
             return nextc == 0;  
    }
}

###3.2.4 FutureTask### 需要记录任务的执行状态,当调用其实例的get方法时,内部类Sync会去调用AQS的acquireSharedInterruptibly()方法,而这个方法会反向调用Sync实现的tryAcquireShared()方法,即让具体实现类决定是否让当前线程继续还是park,而FutureTask的tryAcquireShared方法所做的唯一事情就是检查状态,如果是RUNNING状态那么让当前线程park。而跑任务的线程会在任务结束时调用FutureTask 实例的set方法(与等待线程持相同的实例),设定执行结果,并且通过unpark唤醒正在等待的线程,返回结果

//get时待用,只检查当前任务是否完成或者被Cancel,如果未完成并且没有被cancel,那么告诉AQS当前线程需要进入等待队列并且park住
protected int tryAcquireShared(int ignore) {
     return innerIsDone()? 1 : -1;
}

//判定任务是否完成或者被Cancel
boolean innerIsDone() {
    return ranOrCancelled(getState()) &&    runner == null;
}

//get时调用,对于CANCEL与其他异常进行抛错
V innerGet(long nanosTimeout) throws InterruptedException, ExecutionException, TimeoutException {
    if (!tryAcquireSharedNanos(0,nanosTimeout))
        throw new TimeoutException();
    if (getState() == CANCELLED)
        throw new CancellationException();
    if (exception != null)
        throw new ExecutionException(exception);
    return result;
}

//任务的执行线程执行完毕调用(set(V v))
void innerSet(V v) {
     for (;;) {
        int s = getState();
        //如果线程任务已经执行完毕,那么直接返回(多线程执行任务?)
        if (s == RAN)
            return;
        //如果被CANCEL了,那么释放等待线程,并且会抛错
        if (s == CANCELLED) {
            releaseShared(0);
            return;
        }
        //如果成功设定任务状态为已完成,那么设定结果,unpark等待线程(调用get()方法而阻塞的线程),以及后续清理工作(一般由FutrueTask的子类实现)
        if (compareAndSetState(s, RAN)) {
            result = v;
            releaseShared(0);
            done();
            return;
        }
    }
}

以上4个AQS的使用是比较典型,然而有个问题就是这些状态存在哪里呢?并且是可以计数的。从以上4个example,我们可以很快得到答案,AQS提供给了子类一个int state属性。并且暴露给子类getState()和setState()两个方法(protected)。这样就为上述状态解决了存储问题,RetrantLock可以将这个state用于存储当前线程的重进入次数Semaphore可以用这个state存储许可数CountDownLatch则可以存储需要被countDown的次数,而Future则可以存储当前任务的执行状态(RUNING,RAN,CANCELL)。其他的Synchronizer存储他们的一些状态。

AQS留给实现者的方法主要有5个方法,其中tryAcquire,tryRelease和isHeldExclusively三个方法为需要独占形式获取的synchronizer实现的,比如线程独占ReetranLock的Sync,而tryAcquireShared和tryReleasedShared为需要共享形式获取的synchronizer实现

ReentrantLock内部Sync类实现的是tryAcquire,tryRelease, isHeldExclusively三个方法(因为获取锁的公平性问题,tryAcquire由继承该Sync类的内部类FairSync和NonfairSync实现);Semaphore内部类Sync则实现了tryAcquireShared和tryReleasedShared(与CountDownLatch相似,因为公平性问题,tryAcquireShared由其内部类FairSync和NonfairSync实现)。CountDownLatch内部类Sync实现了tryAcquireShared和tryReleasedSharedFutureTask内部类Sync也实现了tryAcquireShared和tryReleasedShared

© 著作权归作者所有

陶邦仁
粉丝 1688
博文 420
码字总数 1483887
作品 0
海淀
技术主管
私信 提问
聊聊并发系列_Index

聊聊并发系列 聊聊并发(一)深入分析Volatile的实现原理 聊聊并发(二)Java SE1.6中的Synchronized 聊聊并发(三)Java线程池的分析和使用 聊聊并发(四)深入分析ConcurrentHashMap 聊聊并...

陶邦仁
2016/01/04
652
0
聊聊并发(十四)—基于AQS实现互斥信号(BooleanMutex)

并发系列 聊聊并发(一)深入分析Volatile的实现原理 聊聊并发(二)Java SE1.6中的Synchronized 聊聊并发(三)Java线程池的分析和使用 聊聊并发(四)深入分析ConcurrentHashMap 聊聊并发(...

陶邦仁
2015/11/22
342
1
阿里P7架构师带你深入分析AQS实现原理

内容导航 ReentrantLock重入锁的使用引入AQS 什么是AQS AQS的源码分析 简单解释一下J.U.C,是JDK中提供的并发工具包, java.util.concurrent。里面提供了很多并发编程中很常用的实用工具类,比...

Java-飞鱼
06/12
65
0
【死磕Java并发】—– 死磕 Java 并发精品合集

【死磕 Java 并发】系列是 LZ 在 2017 年写的第一个死磕系列,一直没有做一个合集,这篇博客则是将整个系列做一个概览。 先来一个总览图: 【高清图,请关注“Java技术驿站”公众号,回复:脑...

chenssy
2018/07/22
0
0
Java:ConcurrentHashMap的实现机制

探索 ConcurrentHashMap 高并发性的实现机制 Java并发编程之ConcurrentHashMap 聊聊并发(四)——深入分析ConcurrentHashMap 上面的三篇分析是针对java7的,java8中的实现方式已经变化。...

樂天
2015/06/28
141
0

没有更多内容

加载失败,请刷新页面

加载更多

Spring Security 自定义登录认证(二)

一、前言 本篇文章将讲述Spring Security自定义登录认证校验用户名、密码,自定义密码加密方式,以及在前后端分离的情况下认证失败或成功处理返回json格式数据 温馨小提示:Spring Security...

郑清
38分钟前
3
0
php yield关键字以及协程的实现

php的yield是在php5.5版本就出来了,而在初级php界却很少有人提起,我就说说个人对php yield的理解 Iterator接口 在php中,除了数组,对象可以被foreach遍历之外,还有另外一种特殊对象,也就是继承...

冻结not
51分钟前
4
0
servlet请求和响应的过程

本文转载于:专业的前端网站➥servlet请求和响应的过程 1.加载 Servlet类被加载到Java虚拟机中,并且实例化。在这个过程中,web容器(例如tomcat)会调用Servlet类的公开无参构造函数,产生一...

前端老手
52分钟前
4
0
golang 1.13 errors 包来了,不用写“err 气功波”代码

引 这篇是对 errors 包 的姿势挖掘 气功波错误代码 从 http.Get()返回的错误 判断 syscall.ECONNREFUSED 错误.以前要对 go 标准库 error 结构有点熟悉,才能写出下面的代码 func CmdErr(err ...

guonaihong
55分钟前
29
0
喜玛拉雅已听书单

时间倒序排 书名 作者 状态 唐砖 孑与2 进行中 死灵之书(克苏鲁神话合集) 阿卜杜拉·阿尔哈萨德 进行中 赡养人类 刘慈欣 完结 赡养上帝 刘慈欣 完结 中国太阳 刘慈欣 完结 中国太阳 刘慈欣...

Alex_Java
56分钟前
6
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部