栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

AQS源码分析-ReentrantLock&Semaphore

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

AQS源码分析-ReentrantLock&Semaphore

一、AQS是什么

juc包中的大多数同步器实现都是围绕着共同的基础行为,比如等待队 列、条件队列、独占获取、共享获取等,而这些行为的抽象就是基于 AbstractQueuedSynchronizer(简称AQS)实现的,AQS是一个抽象同步框架,可以用来实现一个依赖状态的同步器。

1.1、特性
  • 阻塞等待队列
  • 独占/共享
  • 公平/非公平
  • 可重入
  • 可中断
1.2、数据结构
    private transient volatile Node head;
    private transient volatile Node tail;
    private volatile int state;
两种资源共享方式
  • Exclusive-独占,只有一个线程能执行,如ReentrantLock
  • Share-共享,多个线程可以同时执行,如Semaphore/CountDownLatch
两种队列
  • 同步等待队列: 双向链表,主要用于维护获取锁失败时入队的线程
  • 条件等待队列: 单向链表,使用nextWait来链接,调用await()的时候会释放锁,然后线程会加入到条件队列,调用 signal()唤醒的时候会把条件队列中的线程节点移动到同步队列中,等待再次获得锁。
队列中节点状态
  • 值为0,初始化状态,表示当前节点在sync队列中,等待着获取锁。
  • CANCELLED,值为1,表示当前的线程被取消;
  • SIGNAL,值为-1,表示当前节点的后继节点包含的线程需要运行,也就是unpark;
  • CONDITION,值为-2,表示当前节点在等待condition,也就是在condition队列中;
  • PROPAGATE,值为-3,表示当前场景下后续的acquireShared能够得以执行;
二、独占锁-ReentrantLock

ReentrantLock是一种基于AQS框架的应用实现,是JDK中的一种线程并发访问的同步手段,它的功能类似于synchronized是一种互斥锁,可以保证线程安全。 相对于 synchronized, ReentrantLock具备如下特点:

  • 可中断
  • 可以设置超时时间
  • 可以设置为公平锁
  • 支持多个条件变量
  • 与 synchronized 一样,都支持可重入

总结几点synchronized和ReentrantLock的区别:

  • synchronized是JVM层次的锁实现,ReentrantLock是JDK层次的锁实现;
  • synchronized的锁状态是无法在代码中直接判断的,但是ReentrantLock可以通过 ReentrantLock#isLocked判断;
  • synchronized是非公平锁,ReentrantLock是可以是公平也可以是非公平的;
  • synchronized是不可以被中断的,而ReentrantLock#lockInterruptibly方法是可以被中断的;
  • 在发生异常时synchronized会自动释放锁,而ReentrantLock需要开发者在finally 块中显示释放锁;
  • ReentrantLock获取锁的形式有多种:如立即返回是否成功的tryLock(),以及等待指定时长的获取,更加灵活;
  • synchronized在特定的情况下对于已经在等待的线程是后来的线程先获得锁(回顾 一下sychronized的唤醒策略),而ReentrantLock对于已经在等待的线程是先来的线程 先获得锁;
2.1、示例代码
ReentrantLock reentrantLock = new ReentrantLock();
        for (int i = 0; i < 3; i++) {
            new Thread(()-> {
                try {
                    reentrantLock.lock();
                    System.out.println(Thread.currentThread().getName()+"---获取锁成功-- start exec ");
                    try {
                        Thread.sleep(1000000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }finally {
                    reentrantLock.unlock();
                }
            },"thread-"+i).start();
        }
2.2、源码分析

三、共享锁-Semaphore

Semaphore,俗称信号量,它是操作系统中PV操作的原语在java的实现,它也是基于 AbstractQueuedSynchronizer实现的。 Semaphore的功能非常强大,大小为1的信号量就类似于互斥锁,通过同时只能有一个线程获 取信号量实现。大小为n(n>0)的信号量可以实现限流的功能,它可以实现只能有n个线程同 时获取信号量。
应用场景:可以用于做流量控制,特别是公用资源有限的应用场景

3.1、代码示例
private static ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 50, 60, TimeUnit.SECONDS, new LinkedBlockingDeque<>(200));
    private static Semaphore semaphore = new Semaphore(3);

    public static void main(String[] args) throws InterruptedException {
        for (;;) {
            Thread.sleep(100);
            executor.execute(()->exec());
        }
    }

    public static void exec(){
        try {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName()+"---获取锁成功-- start exec ");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }finally {
            semaphore.release();
        }
    }
3.2、源码分析

三、CountDownLatch

CountDownLatch一般用作多线程倒计时计数器,强制它们等待其他一组(CountDownLatch 的初始化决定)任务执行完成。 CountDownLatch的两种使用场景:

  • 多个线程等待
  • 一个线程等待
3.1 示例1

模拟并发

       CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < 5; i++) {
            int finalI = i;
            new Thread(()-> {
                    try {
                        System.out.println(Thread.currentThread().getName()+ "-运动员+"+finalI+"等待起跑===================");
                        countDownLatch.await();
                        System.out.println(Thread.currentThread().getName()+ "-运动员+"+ finalI +"跑起来===================");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            },"thread-"+i).start();
        }
        Thread.sleep(1000L);
        System.out.println(Thread.currentThread().getName()+ "=========裁判准备鸣枪");
        countDownLatch.countDown();
3.2 示例2

数据汇总-场景应用

    static CountDownLatch dataSummaryCountDownLatch = new CountDownLatch(3);
    public static void dataSummary() throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        Map dataSummaryMap = new HashMap<>();
        new Thread(()->{
            try {
                Thread.sleep(1500L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            dataSummaryCountDownLatch.countDown();
            System.out.println(Thread.currentThread().getName()+ "-"+"汇总数据 名称+");
            dataSummaryMap.put("name","张三");
        },"thread-1").start();

        new Thread(()->{
            try {
                Thread.sleep(2000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            dataSummaryCountDownLatch.countDown();
            System.out.println(Thread.currentThread().getName()+ "-"+"汇总数据 年龄+");
            dataSummaryMap.put("age","18");
        },"thread-2").start();

        new Thread(()->{
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            dataSummaryCountDownLatch.countDown();
            System.out.println(Thread.currentThread().getName()+ "-"+"汇总数据 地址+");
            dataSummaryMap.put("address","北京");
        },"thread-3").start();

        dataSummaryCountDownLatch.await();
        System.out.println("结束时间=="+(System.currentTimeMillis()-currentTimeMillis)/1000);
    }
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/986107.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号