Java并发工具之AQS原理

最新推荐文章于 2024-03-29 16:58:38 发布

程序员翟同学

最新推荐文章于 2024-03-29 16:58:38 发布

阅读量117

点赞数

分类专栏： Java并发编程文章标签：多线程

本文链接：https://blog.csdn.net/qq_36986015/article/details/104907285

版权

Java并发编程专栏收录该内容

24 篇文章 1 订阅

订阅专栏

1. 为什么需要AQS？

AQS:AbstractQueuedSynchronizer，抽象队列同步器；
锁和协作类的共同点：闸门；
ReentrantLock、Semaphore、CountDownLatch、ReentrantReadWriteLock都有类似的协作功能，因为都用了一个共同的基类：AQS；
就ReentrantLock和Semaphore而言可以屏蔽很多细节，有许多共同的部分，将其抽象出来就是AQS；

2. Semaphore和AQS的关系？

Semaphore内部有一个Sync类，Sync类继承了AQS；
CountDownLatch也是这样；
AQS是个工具，把它放到Semaphore、CountDownLatch、ReentrantLock的内部，就可以使用；

3. AQS的比喻

Semaphore：限制资源的数量，一个人面试完了之后，后一个人才能拿到许可证进来面试；
CountDownLatch：群面，等待人到齐；
Semaphore、CountDownLatch这些顶层工具，要做的就是定制规则，剩下的交给AQS来做；

4. AQS的作用？

同步状态的原子管理；
线程的阻塞与解除阻塞；
队列的管理；
AQS是一个用于构建锁、同步器、协作工具类的工具类；
有了AQS，构建线程写作类就容易多了；

5. AQS内部原理解析

AQS由一下三大部分组成：

 1.  state状态，在不同的类中有不同的含义；
 2. 控制线程抢锁和配合的FIFO队列，即存放等待的线程；
 3. 期望协作工具类去实现的获取/释放等重要方法；

5.1 state状态

    /**
     * The synchronization state.
     */
    private volatile int state;

state的具体含义，会根据具体实现类的不同而不同，比如在Semaphore里，它表示“剩余许可证的数量”，在CountDownLatch里，表示“还需要倒数的数量”，在ReentrantLock中，表示锁的占用情况，0表示没有被占有，1表示被持有了，如果有2、3、4…等表示某线程重入了几次；
state是volatile修饰的，会被并发地修改，所以所有的state的方法需要保证线程安全，比如getState、setState以及compareAndSetState（通过硬件级别的原子性保证了应用层操作的原子性）操作来读取和更新这个状态。这些方法都依赖于juc.atomic包的支持；

5.2 控制线程抢锁和配合的FIFO队列

这个队列用来存放“等待的线程”，AQS就是“排队管理器”，当多个线程争用同一把锁时，必须有排队机制将那些没能拿到锁的线程串在一起。当锁释放时，锁管理器就会挑选一个合适的线程占用这个刚刚释放的锁；
AQS会维护一个等待的线程队列，把线程都放在这个队列里；

5.3 协作工具类去实现的获取/释放等

这里的获取和释放方法，是利用AQS的协作工具类里最重要的方法，是由协作类自己去实现的，并且含义各不相同；
获取方法：依赖于State变量，经常会阻塞（比如获取不到锁的情况）；
在Semaphore中，获取就是acquire方法，作用是获取一个许可证；
在CountDownLatch里面，获取就是await方法，直到其他线程把state减成0之后，当前线程才能被唤醒；
释放方法：释放操作不会阻塞；
在Semaphore中，释放就是release方法，作用是释放一个许可证；
CountDownLatch里面，获取就是countDown方法，作用是“倒数一个数”；

需要线程协作类自己去实现的方法：

Semaphore里面的静态内部类Sync中的getPermits、nonfairTryAcquireShared、tryReleaseShared等；
CountDownLatch里面的静态内部类Sync中的getCount、tryAcquireShared、tryReleaseShared等；

6. AQS应用实例、源码解析

6.1 AQS用法

写一个类，想好协作的逻辑，实现获取/释放方法；
内部写一个Sync类继承AQS；
根据是否独占来重写，如果是独占的就重写tryAcquire/tryRelease；如果是共享的就重写tryAcquireShared(int acquires)和tryReleaseShared(int releases)等方法，在步骤1写的获取/释放方法中调用AQS;

6.2 AQS在CountDownLatch的应用

首先创建CountDownLatch并传入倒数的数值5；

CountDownLatch countDownLatch = new CountDownLatch(5);

在CountDownLatch的构造函数中创建Sync对象并传入数值

    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

在Sync的构造函数中调用setState(count)方法设置state

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

在CountDownLatch里面有个getCount()方法

    public long getCount() {
        return sync.getCount();
    }

间接调用了sync.getCount方法

        int getCount() {
            return getState();
        }

sync的getCount方法调用了getState方法

    protected final int getState() {
        return state;
    }

AQS在CountDownLatch的总结：

调用CountDownLatch的await方法时，便会尝试获取共享锁，不过一开始是获取不到该锁的，于是线程被阻塞；
而“共享锁”可获取到的条件，就是“锁计数器”归0；
而“锁计数器”的初始值为count，每当一个线程调用该CountDownLatch对象的countDown方法时，才将“锁计数器”-1；
count个线程调用了countDown之后，锁计数器才为0，而前面提高的等待获取共享锁的线程才能继续运行；

6.3 AQS在Semaphore的应用

在Semaphore中，state就是“剩余许可证的数量”；
看tryAcquire方法，判断nonfairTryAcquireShared大于等于0的话，就表示成功；

        final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }

这里会先检查剩余许可证数量remaining 够不够，如果remaining 小于0，那么直接返回负数，表示失败；如果够了，就自旋加CAS改变state的值，直到改变成功就返回整数；如果期间被其他人修改了导致剩余数量不够了（因为多个线程竞争导致CAS操作也有可能失败，因为for循环自旋的缘故，再次循环到remaining和CAS，都不满足，就进入到下一个循环中，直到满足CAS操作或者remaining 小于0，表示线程获取到remaining ，线程继续执行），那也返回负数表示失败。

6.4 AQS在ReentrantLock的应用

unLock方法，调用了sync的release方法

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

release方法调用了AQS类中的release方法

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

tryRelease方法如下，会先判断当前这个线程是不是持有锁的线程，如果是的话，如果state - 1的结果c等于0就把free改为true并返回，同时把线程持有的锁设置为null，表示没有任何线程持有这把锁，如果不等于0，等于减少了重入的次数，把state的值修改为c

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

lock方法，调用了sync的lock方法，可以看出Sync并没有实现lock方法，是因为lock方法有公平和非公平实现

    public void lock() {
        sync.lock();
    }

abstract void lock();

非公平的实现方法如下，CAS操作表示当前state为0的时候才能成功，表示没有线程持有这把锁的时候才能让当前线程持有，一旦CAS失败就会调用acquire方法，进入阻塞状态或者重入

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

分析释放锁的方法tryRelease：
- 由于是可重入的，所以state代表重入的次数，每次释放锁先判断是不是当前持有锁的线程释放的，如果不是就抛异常，如果是的话，重入次数就减一，如果减到了0，就说明完全释放了，于是free就是true，并且把state设置为0
分析加锁的方法：
- 判断当前state是不是等于0，如果是则让当前线程持有锁，如果不是就判断是不是当前线程又来重入，如果不是当前线程来重入，就进入阻塞状态；

7. AQS实战一个简化版CountDownLatch

/**
 * 一次性门闩，倒数一次，其他线程就开始释放，arg为0表示关闭，为1表示打开
 */
package tools.aqs;

import java.util.concurrent.locks.AbstractQueuedSynchronizer;

/**
 * 一次性门闩，倒数一次，其他线程就开始释放，arg为0表示关闭，为1表示打开
 */
public class OneShotLatch {

    private final Sync sync = new Sync();

    public void countDown() {
        sync.releaseShared(0);
    }

    public void await() {
        sync.acquireShared(0);
    }

    private static class Sync extends AbstractQueuedSynchronizer {

        @Override
        protected int tryAcquireShared(int arg) {
            return getState() == 1 ? 1: -1;//getState等于0，表示门关闭，返回-1，执行await的线程进入阻塞状态，
                                        // 在阻塞状态下不停的自旋，直到tryAcquireShared >= 0，表示10个子线程获取到锁
        }

        @Override
        protected boolean tryReleaseShared(int arg) {
            setState(1);//让10个自旋的线程tryAcquireShared>0，可以获取到锁继续运行
            return true;//释放主线程继续运行
        }
    }

    public static void main(String[] args) throws InterruptedException {
        OneShotLatch oneShotLatch = new OneShotLatch();
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "尝试获取Latch...");
                    oneShotLatch.await();
                    System.out.println(Thread.currentThread().getName() + "门闩打开，继续运行...");
                }
            }).start();
        }
        Thread.sleep(1000);
        oneShotLatch.countDown();

    }
}

Thread-0尝试获取Latch...
Thread-1尝试获取Latch...
Thread-5尝试获取Latch...
Thread-6尝试获取Latch...
Thread-7尝试获取Latch...
Thread-3尝试获取Latch...
Thread-2尝试获取Latch...
Thread-8尝试获取Latch...
Thread-4尝试获取Latch...
Thread-9尝试获取Latch...
Thread-0门闩打开，继续运行...
Thread-1门闩打开，继续运行...
Thread-5门闩打开，继续运行...
Thread-6门闩打开，继续运行...
Thread-7门闩打开，继续运行...
Thread-3门闩打开，继续运行...
Thread-2门闩打开，继续运行...
Thread-8门闩打开，继续运行...
Thread-9门闩打开，继续运行...
Thread-4门闩打开，继续运行...

程序员翟同学

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java并发工具之AQS原理

1. 为什么需要AQS？AQS:AbstractQueuedSynchronizer，抽象队列同步器；锁和协作类的共同点：闸门；ReentrantLock、Semaphore、CountDownLatch、ReentrantReadWriteLock都有类似的协作功能，因为都用了一个共同的基类：AQS；就ReentrantLock和Semaphore而言可以屏蔽很多细节，有许多共同的部分...
复制链接

扫一扫

专栏目录