您当前的位置:首页 > 电脑百科 > 程序开发 > 语言 > JAVA

「Java原理探索」「AQS」教你自定义实现自己的同步器

时间:2021-07-30 10:02:39  来源:掘金  作者:李浩宇Alex

前提概要

之前的文章中会涉及到了相关AQS的原理和相关源码的分析,所谓实践是检验真理的唯一标准!接下来就让我们活化一下AQS技术,主要针对于自己动手实现一个AQS同步器。

定义MyLock实现Lock

Doug Lea大神在JDK1.5编写了一个Lock接口,里面定义了实现一个锁的基本方法,我们只需编写一个MyLock类实现这个接口就好。

class MyLock implements Lock {
    /**
     * 加锁。如果不成功则进入等待队列
     */
    @Override
    public void lock() {}
    /**
    * 加锁(可被interrupt)
    */
    @Override
    public void lockInterruptibly() throws InterruptedException {}
    /**
     * 尝试加锁
     */
    @Override
    public boolean tryLock() {}
    /**
     * 加锁 带超时的
     */
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {}
    /**
    * 释放锁
    */
    @Override
    public void unlock() {}
    /**
    * 返回一个条件变量(不在本案例谈论)
    */
    @Override
    public Condition newCondition() {}
}
复制代码

定义好MyLock后,接下来就是实现各个方法的逻辑,达到真正的用于线程间sync互斥的需求。

自定义一个MySync继承自AQS

接下来我们需要自定义一个继承自AQS的MySync。实现自定义的MySync前,先了解AQS内部的一些基本概念。在AQS中主要的一些成员属性如下:

「Java原理探索」「AQS」教你自定义实现自己的同步器

 

  • state:用于标记资源状态,如果为0表示资源没有被占用,可以加锁成功。如果大于0表示资源已经被占用,然后根据自己的定义去实现是否允许对共享资源进行操作。 比如:ReentrantLock的实现方式是当state大于0,那么表示已经有线程获得锁了,我们都知道ReentrantLock是可重入的,其原理就是当有线程次进入同一个lock标记的临界区时。先判断这个线程是否是获得锁的那个线程,如果是,state会+1,此时state会等于2。 当unlock时,会一层一层地减1,直到state等于0则表示完全释放锁成功。
  • head、tail:用于存放获得锁失败的线程。在AQS中,每一个线程会被封装成一个Node节点,这些节点如果获得锁资源失败会链在head、tail中,成为一个双向链表结构。
  • exclusiveOwnerThread用于存放当前获得锁的线程,正如在state说明的那样。ReentrantLock判断可重入的条件就是用这个exclusiveOwnerThread线程跟申请获得锁的线程做比较,如果是同一个线程,则state+1,并重入加锁成功

知道这些概念后我们就可以自定义一个AQS:

public final class MySync extends AbstractQueuedSynchronizer {
    /**
    * 尝试加锁
    */
    @Override
    protected boolean tryAcquire(int arg) {
        if (compareAndSetState(0, 1)) {
            // 修改state状态成功后设置当前线程为占有锁资源线程
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }
    /**
    * 释放锁
    */
    @Override
    protected boolean tryRelease(int arg) {
        setExclusiveOwnerThread(null);
        // state有volatile修饰,为了保证解锁后其他的一些变量对其他线程可见,把setExclusiveOwnerThread(null)放到上面 hAppens-before中定义的 volatile规则
        setState(0);
        return true;
    }
    /**
    * 判断是否是独占锁
    */
    @Override
    protected boolean isHeldExclusively() {
        return getState() == 1;
    }
}
复制代码

将MySync组合进MyLock

最后一步就是将第一步中的所有方法逻辑完成

class MyLock implements Lock {

    // 组合自定义sync器
    private MySync sync = new MySync();

    /**
     * 加锁。如果不成功则进入等待队列
     */
    public void lock() {
        sync.acquire(1);
    }
    /**
    * 加锁(可被interrupt)
    */
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }
    /**
     * 尝试加锁
     */
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }
    /**
     * 加锁 带超时的
     */
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toMillis(time));
    }
    /**
    * 释放锁
    */
    public void unlock() {
        sync.release(0);
    }
    /**
    * 返回一个条件变量(不在本案例谈论)
    */
    @Override
    public Condition newCondition() {
        return null;
    }
}
复制代码

完成整个MyLock的逻辑后,发现在lock()、unlock()中调用的自定义sync的方法tryAcquire()和tryRelease()方法。我们就以在lock()方法中调用acquire()方法说明模板设计模式在AQS中的应用。

点进.acquire()方法后,发现该该方法是来自
AbstractQueuedSynchronizer中:

「Java原理探索」「AQS」教你自定义实现自己的同步器

 

  • 在这里面可以看到tryAcquire方法,继续点进去看看tryAcquire(),发现该方法是一个必须被重写的方法,否则抛出一个运行时异常。
  • 模板方法设计模式在这里得以体现,再回到我们第二部中自定义的MySync中,就是重写了AQS中的tryAcquire()方法。
「Java原理探索」「AQS」教你自定义实现自己的同步器

 

因此整个自定义加锁的流程如下:

  • 调用MyLock的lock(),lock()方法调用AQS的acquire()方法
  • 在acquire()方法中调用了tryAcquire()方法进行加锁
  • 而tryAcquire()方法在AQS中是一个必须让子类自定义重写的方法,否则会抛出一个异常
  • 因此调用tryAcquire()时实际上是调用了我们自定义的MySync类中tryAcquire()方法

总结

AQS作为JAVA并发体系下的关键类,在各种并发工具中都有它的身影,如ReentrantLock、Semaphore等。这些并发工具用于控制sync互斥的手段都是采用AQS,外加Cas机制。AQS采用了模板方法设计模式让子类们自定义sync互斥的条件,比如本案例中MySync类重写了tryAcquire方法。

下面实现一个自定义的sync:

public class SelfSynchronizer {

    private final Sync sync = new Sync();

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

    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    public boolean unLock() {
        return sync.release(1);
    }

    static class Sync extends AbstractQueuedSynchronizer {
        //是否处于占用状态
        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }

        /**
         * 获取sync资源
         * @param acquires
         * @return
         */
        @Override
        public boolean tryAcquire(int acquires) {
            if(compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            //这里没有考虑可重入锁
            /*else if (Thread.currentThread() == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }*/
            return false;
        }

        /**
         * 释放sync资源
         * @param releases
         * @return
         */
        @Override
        protected boolean tryRelease(int releases) {
            int c = getState() - releases;
            boolean free = false;
            if (c == 0) {
                free = true;
            }
            setState(c);
            return free;
        }
    }
}

复制代码

ReentrantLock源码和上面自定义的sync很相似,测试下该sync,i++在多线程下执行情况:

public class TestSelfSynchronizer {
    private static int a = 0;
    private static int b = 0;
    private static SelfSynchronizer selfSynchronizer = new SelfSynchronizer();
    private static ThreadPoolExecutor executor = new ThreadPoolExecutor(20, 50, 1, TimeUnit.SECONDS,
            new LinkedBlockingQueue<Runnable>());
    private static ExecutorService ec = Executors.newFixedThreadPool(20);
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 20 ; i++) {
            executor.submit(new Task());
        }
        for (int j = 0; j < 20 ; j++) {
            ec.submit(new TaskSync());
        }
        Thread.sleep(10000);
        System.out.println("a的值:"+ a);
        System.out.println("b的值" + b);
        executor.shutdown();
        ec.shutdown();
    }
    static class Task implements Runnable {
        @Override
        public void run() {
            for(int i=0;i<10000;i++) {
                a++;
            }
        }
    }
    static class TaskSync implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
            	//使用sync器加锁
                selfSynchronizer.lock();
                b++;
                selfSynchronizer.unLock();
            }
        }
    }
}
复制代码

开启两个线程池,对int型变量自增10000次,如果不加sync器,最后值小于200000,使用了自定义sync器则最后值正常等于200000,这是因为每次自增操作加锁


作者:李浩宇Alex
链接:
https://juejin.cn/post/6989937347429302280
来源:掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。



Tags:同步器   点击:()  评论:()
声明:本站部分内容及图片来自互联网,转载是出于传递更多信息之目的,内容观点仅代表作者本人,如有任何标注错误或版权侵犯请与我们联系(Email:2595517585@qq.com),我们将及时更正、删除,谢谢。
▌相关推荐
前提概要之前的文章中会涉及到了相关AQS的原理和相关源码的分析,所谓实践是检验真理的唯一标准!接下来就让我们活化一下AQS技术,主要针对于自己动手实现一个AQS同步器。定义MyL...【详细内容】
2021-07-30  Tags: 同步器  点击:(95)  评论:(0)  加入收藏
▌简易百科推荐
一、Redis使用过程中一些小的注意点1、不要把Redis当成数据库来使用二、Arrays.asList常见失误需求:把数组转成list集合去处理。方法:Arrays.asList 或者 Java8的stream流式处...【详细内容】
2021-12-27  CF07    Tags:Java   点击:(3)  评论:(0)  加入收藏
文章目录 如何理解面向对象编程? JDK 和 JRE 有什么区别? 如何理解Java中封装,继承、多态特性? 如何理解Java中的字节码对象? 你是如何理解Java中的泛型的? 说说泛型应用...【详细内容】
2021-12-24  Java架构师之路    Tags:JAVA   点击:(5)  评论:(0)  加入收藏
大家好!我是老码农,一个喜欢技术、爱分享的同学,从今天开始和大家持续分享JVM调优方面的经验。JVM调优是个大话题,涉及的知识点很庞大 Java内存模型 垃圾回收机制 各种工具使用 ...【详细内容】
2021-12-23  小码匠和老码农    Tags:JVM调优   点击:(11)  评论:(0)  加入收藏
前言JDBC访问Postgresql的jsonb类型字段当然可以使用Postgresql jdbc驱动中提供的PGobject,但是这样在需要兼容多种数据库的系统开发中显得不那么通用,需要特殊处理。本文介绍...【详细内容】
2021-12-23  dingle    Tags:JDBC   点击:(12)  评论:(0)  加入收藏
Java与Lua相互调用案例比较少,因此项目使用需要做详细的性能测试,本内容只做粗略测试。目前已完成初版Lua-Java调用框架开发,后期有时间准备把框架进行抽象,并开源出来,感兴趣的...【详细内容】
2021-12-23  JAVA小白    Tags:Java   点击:(10)  评论:(0)  加入收藏
Java从版本5开始,在 java.util.concurrent.locks包内给我们提供了除了synchronized关键字以外的几个新的锁功能的实现,ReentrantLock就是其中的一个。但是这并不意味着我们可...【详细内容】
2021-12-17  小西学JAVA    Tags:JAVA并发   点击:(10)  评论:(0)  加入收藏
一、概述final是Java关键字中最常见之一,表示“最终的,不可更改”之意,在Java中也正是这个意思。有final修饰的内容,就会变得与众不同,它们会变成终极存在,其内容成为固定的存在。...【详细内容】
2021-12-15  唯一浩哥    Tags:Java基础   点击:(14)  评论:(0)  加入收藏
1、问题描述关于java中的日志管理logback,去年写过关于logback介绍的文章,这次项目中又优化了下,记录下,希望能帮到需要的朋友。2、解决方案这次其实是碰到了一个问题,一般的情况...【详细内容】
2021-12-15  软件老王    Tags:logback   点击:(17)  评论:(0)  加入收藏
本篇文章我们以AtomicInteger为例子,主要讲解下CAS(Compare And Swap)功能是如何在AtomicInteger中使用的,以及提供CAS功能的Unsafe对象。我们先从一个例子开始吧。假设现在我们...【详细内容】
2021-12-14  小西学JAVA    Tags:JAVA   点击:(21)  评论:(0)  加入收藏
一、概述观察者模式,又可以称之为发布-订阅模式,观察者,顾名思义,就是一个监听者,类似监听器的存在,一旦被观察/监听的目标发生的情况,就会被监听者发现,这么想来目标发生情况到观察...【详细内容】
2021-12-13  唯一浩哥    Tags:Java   点击:(16)  评论:(0)  加入收藏
相关文章
    无相关信息
最新更新
栏目热门
栏目头条