1. 全栈程序员必看首页

AQS原理及用法_aqs是什么意思

全栈程序员-用户IM • • 未分类

AQS原理及用法_aqs是什么意思AQS原理及用法1AQS简介AQS全称为AbstractQueuedSynchronizer，是Java中的一个抽象类。AQS是一个用于构建锁、同步器、协作工具类的工具类（框架）。有了AQS之后，更多的协作工具类都可以方便得被写出来。有了AQS，构建线程协作类就容易多了。控制并发流程的类，都需要线程等待和唤醒的功能，这是这些类的共同特点，因此可以抽象出一个基类，这就是AQS。AQS广泛用于控制并发流程的类，如下图：其中Sync是这些类中都有的内部类，其结构如下：

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全家桶1年46，售后保障稳定

AQS原理及用法

1 AQS简介

  • AQS全称为AbstractQueuedSynchronizer，是Java中的一个抽象类。

  • AQS是一个用于构建锁、同步器、协作工具类的工具类（框架）。有了AQS之后，更多的协作工具类都可以方便得被写出来。

  • 有了AQS，构建线程协作类就容易多了。

  • 控制并发流程的类，都需要线程等待和唤醒的功能，这是这些类的共同特点，因此可以抽象出一个基类，这就是AQS。

  • AQS广泛用于控制并发流程的类，如下图：

在这里插入图片描述

  • 其中Sync是这些类中都有的内部类，其结构如下：

在这里插入图片描述

  • 可以看到：Sync是AQS的实现。

  • AQS主要完成的任务：

    • （1）同步状态（比如说计数器）的原子性管理；

    • （2）线程的阻塞和解除阻塞；

    • （3）队列的管理。

2 AQS原理

  • AQS最核心的就是三大部分：

    • 状态：state；

    • 控制线程抢锁和配合的FIFO队列（双向链表）；

    • 期望协作工具类去实现的获取/释放等重要方法（重写）。

状态state

  • 这里state的具体含义，会根据具体实现类的不同而不同：比如在Semapore里，他表示剩余许可证的数量；在CountDownLatch里，它表示还需要倒数的数量；在ReentrantLock中，state用来表示“锁”的占有情况，包括可重入计数，当state的值为0的时候，标识该Lock不被任何线程所占有。

  • state是volatile修饰的，并被并发修改，所以修改state的方法都需要保证线程安全，比如getState、setState以及compareAndSetState操作来读取和更新这个状态。这些方法都依赖于unsafe类。

FIFO队列

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

  • AQS会维护一个等待的线程队列，把线程都放到这个队列里，这个队列是双向链表形式。

实现获取/释放等方法

  • 这里的获取和释放方法，是利用AQS的协作工具类里最重要的方法，是由协作类自己去实现的，并且含义各不相同；

  • 获取方法：获取操作会以来state变量，经常会阻塞（比如获取不到锁的时候）

    • 在Semaphore中，获取就是acquire方法，作用是获取一个许可证；

    • 而在CountDownLatch里面，获取就是await方法，作用是等待，直到倒数结束；

  • 释放方法

    • 在Semaphore中，释放就是release方法，作用是释放一个许可证；

    • 在CountDownLatch里面，获取就是countDown方法，作用是将倒数的数减一；

  • 需要每个实现类重写tryAcquire和tryRelease等方法。

3 AQS在juc中的应用

AQS在juc中用法套路：

  • 第一步：写一个类：想好协作的逻辑，实现获取/释放方法；
  • 第二步：类的内部写一个Sync类，继承AbstractQueuedSychronizer；
  • 第三步：根据是否独占来重写 tryAcquire/tryRelease 或 tryAcquireShared(int acquires) /tryReleaseShared(int release) 等方法，在之前写的获取/释放方法中调用、AQS的 acquire/release 或者 acquireShared/releaseShared 方法。
  • 为了方便，下面分析中的AbstractQueuedSynchronizer类都用AQS代替。

3.1 AQS在CountDownLatch中的应用

  • 当我们新建一个CountDownLatch对象时：
CountDownLatch cdl = new CountDownLatch(3);

Jetbrains全家桶1年46，售后保障稳定

  • 会在cdl内部创建一个Sync对象，并将this.sync中的state设置为3，代表要倒数三次。

  • 当我们调用cdl.await()，此时调用该语句的线程会陷入等待，原因分析如下：

  • await()方法中的内容如下：

public void await() throws InterruptedException { 
     // 位于CountDownLatch类中
    sync.acquireSharedInterruptibly(1);
}
  • acquireSharedInterruptibly位于AQS类中，内容如下：
public final void acquireSharedInterruptibly(int arg)
    throws InterruptedException { 
     // 位于AQS类中
    
    if (Thread.interrupted()) throw new InterruptedException();
    
    if (tryAcquireShared(arg) < 0) 
        doAcquireSharedInterruptibly(arg);  // 把当前线程放入队列等待，并且让当前线程阻塞
}
  • tryAcquireShared(arg)被AQS的子类Sync重写，内容如下：
protected int tryAcquireShared(int acquires) { 
     // 位于CountDownLatch类的内部类Sync中
    return (getState() == 0) ? 1 : -1;
}
  • getState()位于AQS类中，内容如下：
protected final int getState() { 
     // 位于AQS类中
    return state;
}
  • 因为getState()返回的是 3，因此tryAcquireShared会返回 -1，因此会执行doAcquireSharedInterruptibly，然后当前线程进入阻塞。

  • 当调用countDown()函数，会让state--，如果值变为0，则会唤醒之前等待的线程。原因分析如下：

  • countDown()方法中的内容如下：

public void countDown() { 
     // 位于CountDownLatch类中
    sync.releaseShared(1);
}
  • releaseShared位于AQS类中，内容如下：
public final boolean releaseShared(int arg) { 
     // 位于AQS类中
    if (tryReleaseShared(arg)) { 
   
        doReleaseShared();  // 把之前阻塞的线程全部唤醒
        return true;
    }
    return false;
}
  • tryReleaseShared(arg)被AQS的子类Sync重写，内容如下：
protected boolean tryReleaseShared(int releases) { 
     // 位于CountDownLatch类的内部类Sync中
    // Decrement count; signal when transition to zero
    for (;;) { 
   
        int c = getState();
        if (c == 0)
            return false;
        int nextc = c-1;
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}
  • 可以看到当state的值减少到 0 之后会唤醒之前阻塞进程。

3.1 AQS在Semaphore中的应用

  • 当我们新建一个Semaphore对象时：
Semaphore s = new Semaphore(3);
  • 会在s内部创建一个NonfairSync对象（继承自Sync），并将this.sync中的state设置为3，代表有三个通行证。

  • 当我们调用s.acquire(2)，会获取到两个许可证，分析如下：

  • acquire(int permits)方法中的内容如下：

public void acquire(int permits) throws InterruptedException { 
     // 位于Semaphore类中
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
}
  • acquireSharedInterruptibly位于AQS类中，内容如下：
public final void acquireSharedInterruptibly(int arg)
    throws InterruptedException { 
     // 位于AQS类中
    
    if (Thread.interrupted()) throw new InterruptedException();
    
    if (tryAcquireShared(arg) < 0) 
        doAcquireSharedInterruptibly(arg);  // 把当前线程放入队列等待，并且让当前线程阻塞
}
  • tryAcquireShared(arg)被AQS的子类Sync重写，内容如下：
protected int tryAcquireShared(int acquires) { 
     // 位于Semaphore类的内部类NonfairSync中
    return nonfairTryAcquireShared(acquires);
}
  • nonfairTryAcquireShared内容如下：
final int nonfairTryAcquireShared(int acquires) { 
     // 位于Semaphore类的内部类Sync中
    for (;;) { 
   
        int available = getState();
        int remaining = available - acquires;
        if (remaining < 0 ||
            compareAndSetState(available, remaining))
            return remaining;
    }
}
  • 上面的available就是state，当我们想要获取的许可证数量acquires小于等于state时，返回正数，在函数acquireSharedInterruptibly判断不成立，不会陷入阻塞，并将state更新为最新的值；否则如果acquires大于state时，返回负数，当前线程会陷入阻塞。

  • 当我们调用s.release(2)，会获取到两个许可证，分析如下：

  • release(int permits)方法中的内容如下：

public void release(int permits) { 
     // 位于Semaphore类中
    if (permits < 0) throw new IllegalArgumentException();
    sync.releaseShared(permits);
}
  • releaseShared位于AQS类中，内容如下：
public final boolean releaseShared(int arg) { 
     // 位于AQS类中
    if (tryReleaseShared(arg)) { 
   
        doReleaseShared();  // 把之前阻塞的线程全部唤醒
        return true;
    }
    return false;
}
  • tryAcquireShared(arg)被AQS的子类Sync重写，内容如下：
protected final boolean tryReleaseShared(int releases) { 
     // 位于Semaphore类的内部类Sync中
    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;
    }
}
  • 该函数会将state的值增加releases，也就是增加许可证的数量。

3.1 AQS在ReentrantLock中的应用

  • 当我们新建一个ReentrantLock对象时：
ReentrantLock r = new ReentrantLock();
  • 会在r内部创建一个NonfairSync对象sync（继承自Sync）。

  • 当我们调用r.lock()，分析如下：

  • r.lock()方法中的内容如下：

public void lock() { 
     // 位于ReentrantLock类中
    sync.lock();
}
  • sync.lock()内容如下：
final void lock() { 
     // 位于ReentrantLock类的内部类NonfairSync中
    if (compareAndSetState(0, 1))  // CAS只有在没有人持有这把锁的时候才能成功
        setExclusiveOwnerThread(Thread.currentThread());  // 把当前线程设置为持有锁的线程
    else
        acquire(1);
}
  • acquire(1)位于AQS类中，内容如下：
public final void acquire(int arg) { 
     // 位于AQS类中
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
  • tryAcquire内容如下：
protected final boolean tryAcquire(int acquires) { 
     // 位于ReentrantLock类的内部类NonfairSync中
    return nonfairTryAcquire(acquires);
}
  • nonfairTryAcquire内容如下：
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;
}
  • 由该函数可以看出，当state为0时，代表没有任何人持有该锁，获取该锁；否则如果当前线程正好是该锁的持有者，重入。

  • 当我们调用r.unlock()，分析如下：

  • r.unlock()方法中的内容如下：

public void unlock() { 
     // // 位于ReentrantLock类中
    sync.release(1);
}
  • sync.release(1)内容如下：
public final boolean release(int arg) { 
     // 位于AQS类中
    if (tryRelease(arg)) { 
   
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}
  • tryRelease被AQS的子类Sync重写，内容如下：
protected final boolean tryRelease(int releases) { 
     // 位于ReentrantLock类的内部类Sync中
    int c = getState() - releases;  // 将重入次数减少releases
    if (Thread.currentThread() != getExclusiveOwnerThread())  // 判断当前线程是不是持有锁的线程
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) { 
     // 只有当重入次数为0时，才去释放锁
        free = true;
        setExclusiveOwnerThread(null);  // 设置当前持有这把锁的线程为null
    }
    setState(c);
    return free;
}
  • 可以看到state的值被减去releases，如果state变为0，则设置当前持有这把锁的线程为null。
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/234952.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0


相关推荐

  • Java输入输出

    Java输入输出

    源代码见：点击打开链接引言：在平时java开发中，被输入输出搞得头疼。特此写下这篇博客，一是为了总结输入输出，二是为了和大家分享。如果大家觉得写得好，就请高抬贵手点个赞呗！！！1.输入格式，输出格式控制1.1输入处理java的输入，我们用到Scanner类，可以用它创建一个对象Scannerreader=newScanner(System.in);…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年4月3日
  • Sequelize多表联合查询案例

    Sequelize多表联合查询案例

    Sequelize多表联合查询案例一、Table：现在有两个表，A和B，关联关系：MATCH表中的job_history_id与JOB_HISTORY表中的id相关联。二、需求：查询Match表中的user_id,report_comment,以及job_history_id所关联的JOB表中的job_link，在前端显示。三、Code:1.后端首先要建立两个表的关联：MatchScoreReportModel.belongsTo(JobHistoryModel,{foreignKey:’job_history

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年5月18日
  • .h5文件的读取_python读写h5文件

    .h5文件的读取_python读写h5文件

    .h5文件的读取_python读写h5文件**关于hdf5文件**HDF（HierarchicalDataFormat）指一种为存储和处理大容量科学数据设计的文件格式及相应库文件。详见其官方介绍：https://support.hdfgroup.org/HDF5/。Python中有一系列的工具可以操作和使用HDF5数据，这里只介绍h5py。一个HDF5文件是存储两类对象的容器，这两类对象分别为：dataset…

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年9月9日
  • 阅读《构造之法》第8,9,10章读后感

    阅读《构造之法》第8,9,10章读后感

    阅读《构造之法》第8,9,10章读后感

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年9月15日
  • 纯CSS3实现动态火车行驶特效

    纯CSS3实现动态火车行驶特效

    上次开完飞机，这次开火车查看效果：http://hovertree.com/texiao/css3/7/效果图：代码如下：转自：http://hovertree.com/h/bjaf/hovertr

    全栈程序员-用户IM 全栈程序员-用户IM
    2021年12月22日
  • df 命令详解「建议收藏」

    df 命令详解「建议收藏」

    df 命令详解「建议收藏」df命令是用来查看linux系统服务器文件系统的磁盘使用情况。可以用该命令来查看已经使用了多少空间，还有多少空间可用。       df命令格式为df[选线][文件名]       df命令功能：显示指定磁盘文件的使用情况。如果没有指定文件，则显示所有挂载的文件系统的磁盘使用情况      选项可以有            -a：全部文件系统列表，包含虚拟文件系统

    全栈程序员-用户IM 全栈程序员-用户IM
    2022年4月20日

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号