并发编程9 - AQS

最新推荐文章于 2024-10-27 15:49:02 发布
最新推荐文章于 2024-10-27 15:49:02 发布
阅读量71 收藏
点赞数
分类专栏： 并发编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39505091/article/details/119849073
版权

文章目录

一. AQS 定义

AQS：AbstractQuenedSynchronizer 抽象的队列式同步器，是除 synchronized 之外的锁机制。ReentrantLock 即是基于AQS实现的独占锁。

AQS基于 CLH 队列，用 volatile 修饰共享变量 state，线程通过 CAS 去改变 state 的值，成功则获取锁成功，失败则进入等待队列，等待被唤醒。

利用 AQS 实现自定义锁：

class MyAQSLock implements Lock {

    //内部类，利用AQS实现自定义锁
    class AQSLock extends AbstractQueuedSynchronizer {
        @Override
        protected boolean tryAcquire(int arg) {
        	// CAS 修改状态
            if (compareAndSetState(0, 1)) {
            	//设置锁的所有者为当前线程
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        //这个方法无需加锁，因为每次只有一个线程会访问该方法
        @Override
        protected boolean tryRelease(int arg) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        //是否锁被独占
        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
    }

    private AQSLock lock = new AQSLock();

    @Override
    public void lock() {
        lock.acquire(1);
    }
    
	//可打断
    @Override
    public void lockInterruptibly() throws InterruptedException {
        lock.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        return lock.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return lock.tryAcquireNanos(1, unit.toNanos(time));
    }

    @Override
    public void unlock() {
        lock.release(1);
    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

二. 读写锁

1. ReentrantReadWriteLock

当读操作的频率远远高于写时，可以考虑使用读写锁 ReentrantReadWriteLock，读锁在 “读-读” 操作时可以实现并发，在 “读-写” 操作时会互斥。即读锁与写锁互斥。
示例：

class Data {
    private static final Logger logger = LoggerFactory.getLogger(Data.class);
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private ReentrantReadWriteLock.ReadLock rLock = rwLock.readLock();
    private ReentrantReadWriteLock.WriteLock wLock = rwLock.writeLock();

    public void getData() throws InterruptedException {
        logger.info("获取读锁");
        rLock.lock();
        try {
            logger.info("获取读锁成功");
            Thread.sleep(1000);
        } finally {
            logger.info("释放读锁");
            rLock.unlock();
        }
    }

    public void putData() throws InterruptedException {
        logger.info("获取写锁");
        wLock.lock();
        try {
            logger.info("获取写锁成功");
            Thread.sleep(1000);
        } finally {
            logger.info("释放写锁");
            wLock.unlock();
        }
    }
}

测试：

public static void main(String[] args) {
 	Data data = new Data();
    new Thread(() -> {
        try {
            data.getData();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }).start();

    new Thread(() -> {
        try {
            data.putData();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }).start();
}

读写互斥：
在这里插入图片描述
读读并发：
在这里插入图片描述
注意：

  • 读锁不支持条件变量；
  • 重入时升级不支持，即同一个线程获取了读锁后再去获取写锁会导致获取写锁永久等待；但重入时支持降级，即获取了写锁后可以再获取读锁。

应用：缓存读取、缓存更新

2. StampedLock

由于 ReentrantReadWriteLock 在实现读读并发时还是需要通过CAS的方式不断修改锁的标识位，其性能肯定不如不加锁。StampedLock 在读的过程中采用了乐观读的方式，即配合一个 “戳” 使用。首先获取戳，读完之后验戳，只有验戳失败以后才加读锁重新读取，最大性地提升读的性能。

class MyStampedLock {
    private static final Logger logger = LoggerFactory.getLogger(MyStampedLock.class);
    private StampedLock stampedLock = new StampedLock();
    private int data;

    public MyStampedLock(int data) {
        this.data = data;
    }

    public int getData() {
    	//乐观读，没有加锁，只是获取了戳	
        long stamp = stampedLock.tryOptimisticRead();
        logger.info("乐观读：" + stamp);
        try {
            Thread.sleep(1000); //模拟读的过程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //验戳失败，加读锁
        if (stampedLock.validate(stamp)) {
            logger.info(stamp + "验证通过");
            return data;
        }
        stamp = stampedLock.readLock();
        logger.info("获取读锁：" + stamp);
        try {
            Thread.sleep(1000); //模拟读的过程，重新读取
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            logger.info("释放读锁：" + stamp);
            stampedLock.unlockRead(stamp);
        }
        return data;
    }

    public void setData(int data) {
    	//写的时候直接加写锁
        long stamp = stampedLock.writeLock();
        logger.info("获取写锁：" + stamp);
        try {
            Thread.sleep(1000);
            this.data = data;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            logger.info("释放写锁：" + stamp);
            stampedLock.unlockWrite(stamp);
        }
    }
}

两个线程并发读：

public static void main(String[] args) throws InterruptedException {
 	MyStampedLock myStampedLock = new MyStampedLock(1);
    new Thread(() -> {
      myStampedLock.getData();
    }, "t1").start();
    Thread.sleep(500);
    new Thread(() -> {
        myStampedLock.getData();
    }, "t2").start();
}

在这里插入图片描述
一个线程读，一个线程写：

public static void main(String[] args) throws InterruptedException {
 	MyStampedLock myStampedLock = new MyStampedLock(1);
    new Thread(() -> {
      myStampedLock.getData();
    }, "t1").start();
    Thread.sleep(500);
    new Thread(() -> {
        myStampedLock.setData(2);
    }, "t2").start();
}

在这里插入图片描述

三. Semaphore 信号量

用来限制同时访问共享资源的线程数量上限，可用于限流。

Semaphore semaphore = new Semaphore(n);
semaphore.acquire();
semaphore.release();

用法示例：当许可数量为2时，4个线程只有2个能获得许可，其他线程将被阻塞，直到许可被释放后，其他线程才能重新获得许可。（可代替 wait/notify ）

public static void main(String[] args) {
	Semaphore semaphore = new Semaphore(2);
    for (int i = 0; i < 4; i++) {
        new Thread(() -> {
            try {
                semaphore.acquire();
                logger.info("获得许可");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
            logger.info("释放许可……");

        }).start();
    }
}

在这里插入图片描述

四. CountDownLatch

用于倒计时等待所有线程结束。类似于 join，但是 join 属于比较底层的 API，join 必须等到线程完全结束，释放连接才行，无法配合线程池使用。

CountDownLatch 配合线程池使用示例：

public class CountDownLatchTest {
    private static final Logger logger = LoggerFactory.getLogger(CountDownLatchTest.class);
    public static void main(String[] args) throws InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(3);
        CountDownLatch countDownLatch = new CountDownLatch(3);
        service.execute(() -> {
            try {
                logger.info("线程0启动");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();
            logger.info("线程0结束--" + countDownLatch.getCount());
        });
        service.execute(() -> {
            try {
                logger.info("线程1启动");
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();
            logger.info("线程1结束--" + countDownLatch.getCount());
        });
        service.execute(() -> {
            try {
                logger.info("线程2启动");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            countDownLatch.countDown();
            logger.info("线程2结束--" + countDownLatch.getCount());
        });
        logger.info("等待子线程结束……");
        countDownLatch.await();
        logger.info("等待结束！");

    }
}

在这里插入图片描述
实际上如果有返回结果需要同步，可以考虑使用 Future 接收结果。

五. CyclicBarrier

CountDownLatch 的局限性是不能重复使用，即当计数减为1时，无法重新设置count 值继续计数。CyclicBarrier 也是通过计数等待所有线程结束，但是弥补了这一缺陷。当 count 值减为 0 时，如果继续调用 CyclicBarrier 对象的 await() 方法，该对象的 count 值又会从初始值开始。

public class CyclicBarrierTest {
    private static final Logger logger = LoggerFactory.getLogger(CyclicBarrierTest.class);
    public static void main(String[] args) {
        //CyclicBarrier 可重用，当计数减到0时，下次调用await又会从初始值开始
        CyclicBarrier cyclicBarrier = new CyclicBarrier(2, ()->{
            logger.info("线程1、2同步完毕"); //参数二为同步完成后执行的代码
        });

        ExecutorService service = Executors.newFixedThreadPool(2);

        for (int i = 0; i < 3; i++) {
            service.execute(() -> {
                try {
                    logger.info("线程1开始执行");
                    Thread.sleep(1000);
                    cyclicBarrier.await(); //计数减一，进入同步等待，当 count 减为0时退出等待
                    logger.info("线程1执行完毕");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });

            service.execute(() -> {
                try {
                    logger.info("线程2开始执行");
                    Thread.sleep(2000);
                    cyclicBarrier.await(); //计数减一，进入同步等待，当 count 减为0时退出等待
                    logger.info("线程2执行完毕");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });
        }
        service.shutdown();
    }
}

在这里插入图片描述

注意：CyclicBarrier 初始化的 count 值必须与线程数保持一致，否则不能起到同步的效果。

weixin_39505091
关注
专栏目录
java并发编程-AQS和JUC实战
04-29
### Java并发编程-AQS和JUC实战 #### 一、ReentrantLock 重入锁 **1.1 概述** - **基本介绍**: `ReentrantLock` 是一个实现了 `Lock` 接口的可重入互斥锁，提供比 `synchronized` 更丰富的功能。与 `synchronized...
joeylv#joscrapy#【Java并发编程实战】-----AQS(四)：CLH同步队列1
07-25
在线程获取锁时会调用AQS的acquire()方法，该方法第一次尝试获取锁如果失败，会将该线程加入到CLH队列中：public final void acqui
并发编程--AQS源码分析
zhang09090606的博客
09-01 169
一、简介 AQS全称AbstractQueuedSynchronizer,它是为实现依赖于先进先出（FIFO）等待队列的阻塞锁和相关同步器（信号量，事件等）提供的一个框架。AQS继承了AbstractOwnableSynchronizer类，这个类为创建锁和相关同步器提供了基础。AQS是Concurrent包的核心,lock就是在AQS的基础上实现的，阻塞队列，线程池，信号量等都离不开AQS的支持。 二、Node节点 AQS主要是维护了一个队列同步器，而队列中主要是存储Node节...
并发编程-05AQS原理
落雪
07-07 810
juc'包中的大多数同步器实现都是围绕着共同的基础行为，比如等待队列、条件队列、独占获取、共享获取等，而这些行为的抽象就是基于 AbstractQueuedSynchronizer（简称AQS）实现的，本章就基于AQS来，通过ReentrantLock同步锁讲解AQS的视线原理
Java并发编程-AQS
YMY哈的博客
10-09 1470
Java并发编程-AQS
Java并发编程--AQS与自定义锁
zwt122755527的博客
12-02 1454
什么是AQS AQS（Abustact Queued Synchronizer 抽象队列化同步器）是用来为Java的并发同步组件提供统一的底层支持，例如 ReentrantLock, CountdowLatch 都是基于AQS实现的。AQS采用模板方法设计模式，我们可以通过简单的继承实现模板方法，来自定义我们自己的锁。 AQS的常用方法 AQS定义两种资源共享方式：Exclusive（...
Java并发编程- AQS原理
wflovejava的博客
07-24 363
Java并发编程- AQS原理
Java-并发编程-AQS
Java程序员的知识博客
02-03 979
AQS 的全称为，翻译过来的意思就是抽象队列同步器。这个类在包下面。AQS 就是一个抽象类，主要用来构建锁和同步器。AQS 为构建锁和同步器提供了一些通用功能的是实现，因此，使用 AQS 能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的Semaphore，其他的诸如等等皆是基于 AQS 的。使用者继承并重写指定的方法。将 AQS 组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法。这和我们以往通过实现接口的方式有很大区别，这是模板方法模式很经典的一个运用。
Java并发 - AQS详解
--土拨鼠--
01-17 1919
在Java并发编程中，我们经常听到AQS（AbstractQueuedSynchronizer）这个概念，它是Java中锁的核心之一。本文将深入介绍AQS，通过提出一系列问题，带你深入了解AQS的定义、实现、资源获取方式以及应用场景。
并发编程------AQS（一）
龙小虬的博客
04-26 124
AQS是AbstractQueuedSynchronizer的简称。AQS提供了一种实现阻塞锁和一系列依赖FIFO等待队列的同步器的框架，如下图所示。AQS为一系列同步器依赖于一个单独的原子变量（state）的同步器提供了一个非常有用的基础。子类们必须定义改变state变量的protected方法，这些方法定义了state是如何被获取或释放的。鉴于此，本类中的其他方法执行所有的排队和阻塞机制。子类也可以维护其他的state变量，但是为了保证同步，必须原子地操作这些变量。 上面也提到了，他是并发中的同步队列
【并发编程】--AQS实现原理
田成荣
07-31 454
AQS lock之所以能实现线程安全的锁，主要的核心是AQS(AbstractQueuedSynchronizer)，AQS提供了一个FIFO队列，可以用来实现锁以及需要同步功能的框架。称为AQS。 AQS使用依靠继承来完成，子类通过继承自AQS并实现所需的方法来管理同步状态。ReentrantLock、CountDownLatch。 AQS分为两种：独占和共享。 独占锁模式下，每次只能有一...
并发编程-AQS
痞子的博客
02-07 109
并发编程之AQS框架 一、定义 AQS是AbstactQueuedSynchronizer的简称，它是一个Java提供的底层同步工具类，用一个int类型的变量表示同步状态，并提供了一系列的CAS操作来管理这个同步状态。AQS的主要作用是为Java中的并发同步组件提供统一的底层支持，例如ReentrantLock，CountdowLatch就是基于AQS实现的，用法是通过继承AQS实现其模版方法，然后将子类作为同步组件的内部类。 总结： 全称是AbstactQueuedSynchronizer 阻塞
Java并发编程：用AQS写一把可重入锁
02-24
之所以把这一章节叫做AQS简介而不是叫AQS详解，是因为已经有大神写过详解的文章Java并发之AQS详解，这篇文章对AQS的源码解析很透彻，博主读了之后受益匪浅，鉴于对原作者的尊重，所以如上附上原文的链接。...
junit5使用suite功能
fanfangyu的博客
10-23 241
2.调用类需要的代码。
Java中的序列化和反序列化？
程序猿老白~的博客
10-23 464
Java中的序列化和反序列化？
java_方法递归调用
最新发布
HHppGo的博客
10-27 259
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
Spring框架注解开发
2401_85217463的博客
10-23 909
名称：@Component @Controller @Service @Repository类型：类注解位置：类定义上方作用：设置该类为spring管理的bean。
RocketMQ | 源码分析 | MappedFile核心存储类
蘑菇蘑菇不会开花的专栏
10-24 1118
RocketMQ的存储都基于MappedFile实现，如CommitLog、Index索引、ConsumeQueue等，本文则主要介绍的实现机制，包括MappedFileQueue类介绍、MappedFile类介绍、预热、MappedFile预分配服务AllocateMappedFileService、MappedFile刷盘等内容。
Swagger--注解大全
IT利刃出鞘的博客
10-25 583
本文介绍Swagger的注解的用法。
Java并发编程深度解析：AQS与ReentrantLock实战
"Java并发编程的关键在于理解和掌握抽象队列同步器（AQS）及其在ReentrantLock等并发工具中的应用。AQS是Doug Lea创造的，它为线程同步提供了一种高效的抽象框架，是Java并发编程的核心组件。" AQS...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值