基于AQS实现互斥信号(BooleanMutex)

最新推荐文章于 2021-08-16 11:38:00 发布
最新推荐文章于 2021-08-16 11:38:00 发布
阅读量273 收藏 1
点赞数
分类专栏： java opensource 文章标签： java 大数据

背景

  最近一个月都在做项目，我主要负责分布式任务的调度的功能，需要实现一个分布式的授权控制。

  具体的需求：

  1.  首先管理员启动整个任务，并设置执行权限

  2.  工作节点收到消息后就会创建对应的线程，并开始执行任务(任务都是由一个管理员进行分配)

  3.  运行过程中管理员需要临时中断某个任务，需要设置一个互斥信号，此时对应的工作节点都需要被阻塞，注意不是完全销毁

分析

 先抛开分布式通讯这一块，首先从单个jvm如何实现进行分析, 简单点来说：

 在单jvm中就是两种线程，一个为manager，另一种为worker。1:n的对应关系，manager可以随时挂起worker的所有线程，而worker线程互不干扰。

 

 咋一看，会觉得是一个比较典型的读写锁的应用场景，读写锁特性：

  • 当读写锁是写加锁状态时, 在这个锁被解锁之前, 所有试图对这个锁加锁的线程都会被阻塞.
  • 当读写锁在读加锁状态时, 所有试图以读模式对它进行加锁的线程都可以得到访问权, 但是如果线程希望以写模式对此锁进行加锁, 它必须直到知道所有的线程释放锁.

使用读写锁实现这样的功能会存在一个问题，就是对应的写锁是没有抢占权，比如当前有读锁未释放时，写锁一直会被阻塞。而项目的需求是，manager是个领导，它可以不用排队，随时打断你。

除此之外，整个worker线程操作会是一个跨方法，跨类的复杂实现。通过lock方式实现，异常稍微处理不好，很容易造成锁未释放，导致manager一直拿不到对应的锁操作。而且worker中本省会使用一些lock操作，容易造成死锁

 

总结一下： 

  1. 需要的是一个类似于信号量的PV控制
  2. 具有的读写锁的，读线程可以不互相影响，写线程拥有最高的抢占权，可以不理会读线程是否在操作
  3. 支持线程中断 (worker线程需要允许cancel)
因此本文的互斥信号(BooleanMutex)就应运而生，它是信号量(Semaphore)的一个变种，加入了读锁的特性。比如在状态为1时可以一直得到响应，对应的P操作不会消费对应的资源

实现

  基于jdk 1.5之后的concurrent的AQS，实现了一个自己的互斥信号控制。 A.Q.S的可以看我的另一篇文章：jdk中cocurrent下的AbstractQueuedSynchronizer理解记录

 

  代码：

 

public class BooleanMutex {

    private Sync sync;

    public BooleanMutex() {
        sync = new Sync();
        set(false);
    }

    public BooleanMutex(Boolean mutex) {
        sync = new Sync();
        set(mutex);
    }

    /**
     * 阻塞等待Boolean为true
     * 
     * @throws InterruptedException
     */
    public void get() throws InterruptedException {
        sync.innerGet();
    }

    /**
     * 阻塞等待Boolean为true,允许设置超时时间
     * 
     * @param timeout
     * @param unit
     * @throws InterruptedException
     * @throws TimeoutException
     */
    public void get(long timeout, TimeUnit unit) throws InterruptedException, TimeoutException {
        sync.innerGet(unit.toNanos(timeout));
    }

    /**
     * 重新设置对应的Boolean mutex
     * 
     * @param mutex
     */
    public void set(Boolean mutex) {
        if (mutex) {
            sync.innerSetTrue();
        } else {
            sync.innerSetFalse();
        }
    }

    public boolean state() {
        return sync.innerState();
    }

    /**
     * Synchronization control for BooleanMutex. Uses AQS sync state to
     * represent run status
     */
    private final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -7828117401763700385L;

        /** State value representing that TRUE */
        private static final int  TRUE             = 1;
        /** State value representing that FALSE */
        private static final int  FALSE            = 2;

        private boolean isTrue(int state) {
            return (state & TRUE) != 0;
        }

        /**
         * 实现AQS的接口，获取共享锁的判断
         */
        protected int tryAcquireShared(int state) {
            // 如果为true，直接允许获取锁对象
            // 如果为false，进入阻塞队列，等待被唤醒
            return isTrue(getState()) ? 1 : -1;
        }

        /**
         * 实现AQS的接口，释放共享锁的判断
         */
        protected boolean tryReleaseShared(int ignore) {
            //始终返回true，代表可以release
            return true;
        }

        boolean innerState() {
            return isTrue(getState());
        }

        void innerGet() throws InterruptedException {
            acquireSharedInterruptibly(0);
        }

        void innerGet(long nanosTimeout) throws InterruptedException, TimeoutException {
            if (!tryAcquireSharedNanos(0, nanosTimeout))
                throw new TimeoutException();
        }

        void innerSetTrue() {
            for (;;) {
                int s = getState();
                if (s == TRUE) {
                    return; //直接退出
                }
                if (compareAndSetState(s, TRUE)) {// cas更新状态，避免并发更新true操作
                    releaseShared(0);//释放一下锁对象，唤醒一下阻塞的Thread
                }
            }
        }

        void innerSetFalse() {
            for (;;) {
                int s = getState();
                if (s == FALSE) {
                    return; //直接退出
                }
                if (compareAndSetState(s, FALSE)) {//cas更新状态，避免并发更新false操作
                    setState(FALSE);
                }
            }
        }

    }
}

 

 

代码其实还是挺简单的，主要是对AQS的一份扩展实现。 对应的javadoc和使用说明：


 

 

简单测试代码：

 

@Test
    public void test_init_true() {
        BooleanMutex mutex = new BooleanMutex(true);
        try {
            mutex.get(); //不会被阻塞
        } catch (InterruptedException e) {
            want.fail();
        }
    }

    @Test
    public void test_init_false() {
        final BooleanMutex mutex = new BooleanMutex(false);
        try {
            final CountDownLatch count = new CountDownLatch(1);
            ExecutorService executor = Executors.newCachedThreadPool();

            executor.submit(new Callable() {

                public Object call() throws Exception {
                    Thread.sleep(1000);
                    mutex.set(true);
                    count.countDown();
                    return null;
                }
            });

            mutex.get(); //会被阻塞，等异步线程释放锁对象
            count.await();
            executor.shutdown();
        } catch (InterruptedException e) {
            want.fail();
        }
    }

    @Test
    public void test_concurrent_true() {
        try {
            final BooleanMutex mutex = new BooleanMutex(true);
            final CountDownLatch count = new CountDownLatch(10);
            ExecutorService executor = Executors.newCachedThreadPool();

            for (int i = 0; i < 10; i++) {
                executor.submit(new Callable() {

                    public Object call() throws Exception {
                        mutex.get();
                        count.countDown();
                        return null;
                    }
                });
            }
            count.await();
            executor.shutdown();
        } catch (InterruptedException e) {
            want.fail();
        }
    }

    @Test
    public void test_concurrent_false() {
        try {
            final BooleanMutex mutex = new BooleanMutex(false);//初始为false
            final CountDownLatch count = new CountDownLatch(10);
            ExecutorService executor = Executors.newCachedThreadPool();

            for (int i = 0; i < 10; i++) {
                executor.submit(new Callable() {

                    public Object call() throws Exception {
                        mutex.get();//被阻塞
                        count.countDown();
                        return null;
                    }
                });
            }
            Thread.sleep(1000);
            mutex.set(true);
            count.await();
            executor.shutdown();
        } catch (InterruptedException e) {
            want.fail();
        }
    }

总结

 

  1. jdk中的A.Q.S代码还是非常精悍的，可以多多善于利用
  2. 单机版的互斥控制只是整个需求的第一步，会另起文章介绍整个分布式任务调度这一块，主要是基于zookeeper

 

iteye_7245
关注
专栏目录
基于AQS原理实现的锁
疾风先生的博客
02-04 1416
1. AQS概念及其组件 AQS基础概念及其作用 AQS基础概念 AQS: 即抽象队列同步器,AbstractQueuedSynchronizer AQS之shared mode: 即共享锁/读锁,用于线程读取加锁,不能进行写操作,可以读读共享 AQS之exclusive mode: 即独占锁/排他锁/写锁,用于线程原子写操作时加锁,只能一个线程持有,其他线程处于等待状态 AQS中不同m...
AQS的应用：基于AQS实现自定义同步器
weixin_43395911的博客
12-24 467
微信公众号：Zhongger 我是Zhongger，一个在互联网行业摸鱼写代码的打工人！ 关注我，了解更多你不知道的【Java后端】打工技巧、职场经验、生活感悟等 三、基于AQS实现自定义同步器 之前学习了这么多关于AQS的原理性的知识，这一期，我们来基于AQS实现一个不可重入的独占锁， 自定义AQS需要重写一系列函数，还需要定义原子变量state的含义。这里我们定义， state=0 表示目前锁没有被线程持有 ，state=1 表示锁己经被某一个线程持有。 由于是不可重入锁，所以不需要记录持有锁的线.
使用AQS实现 独占锁 Mutex
yuzhiyun3536的专栏
09-14 644
Lock想要弄懂lock的原理，就得首先理解AQS，理解之前，先学会使用它。Mutex“` import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.AbstractQueuedSynchronizer; import java.util.concurrent.locks.Condition; import
JUC 高并发编程(12)：AQS 与 三大工具类：CountDownLatch，CyclicBarrier，Semaphore，ReentrantLock，Mutex
Mr_tianyanxiaobai的博客
08-16 266
AQS 三大工具类 CountDownLatch CyclicBarrier Semaphore
【Zookeeper系列四】ZooKeeper 分布式锁实现
weixin_34032621的博客
11-18 194
为什么80%的码农都做不了架构师？>>> ...
AQS互斥锁
luxianping的专栏
02-25 674
背景： 实现单机版任务调度的功能（分布式后续考虑，暂时先单进程） 1.首先管理员启动整个任务，并设置执行权限   2.工作节点收到消息后就会创建对应的线程，并开始执行任务(任务都是由一个管理员进行分配)   3.运行过程中管理员需要临时中断某个任务，需要设置一个互斥信号，此时对应的工作节点都需要被阻塞，注意不是完全销毁 import java.util.concurrent.Callab
Java多线程同步设计中使用Mutex
z69183787的专栏
08-31 9952
Mutex是互斥体，广泛地应用在多线程编程中。本文以广为流程的Doug Lea的concurrent工具包的Mutex实现为例，进行一点探讨。在Doug Lea的concurrent工具包中，Mutex实现了Sync接口，该接口是concurrent工具包中所有锁（lock）、门（gate）和条件变量（condition）的公共接口，Sync的实现类主要有：Mutex、Semaphore及其子
基于AQS的互斥与同步机制探究
AQS基于FIFO等待队列的机制，通过内部的状态变量、CAS操作等手段实现了线程的互斥和同步。通过AQS，开发者可以方便地定义自己的同步器，并且可以利用已经实现的AQS相关类，如ReentrantLock、Semaphore等。 ## 1.2 ...
基于 AQS 实现读写锁
kiss_kings的博客
06-12 1375
AQS -- AbstractQueuedSynchronizer 首先介绍一下 AbstractQueuedSynchronizer （抽象队列同步器）: 队列同步器AbstractQueuedSynchronizer（以下简称同步器），是用来构建锁或者其他同步组件的基础框架；位于 java.util.concurrent.locks 包下; 它使用了一个信号量(state)表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作； AbstractQueuedSynchronizer 使
AQS如何实现互斥访问？
AQS的主要作用是提供一种基于FIFO等待队列的同步器框架，它可以用来构建各种形式的同步器，如独占锁（ReentrantLock）、共享锁（Semaphore、CountDownLatch等）等。AQS的特点包括灵活性、可扩展
关于Mutex的构造函数参数设置
阿达King哥的博客
11-05 4273
Mutex的英文解释就是互斥体，也就是线程或者进程在同时访问一个资源的时候，是需要排他访问，也就是说一个时间段内只能有一个线程对象访问公共资源。 Mutex的构造函数分为Mutex()，Mutex(Boolean),Mutex(boolean, string)。 下面就较这3个构造函数分别进行比较分析。 1、  Mutex()这样一个构造函数相当于执行了Mutex(false)，这样一个构造
关于用信号量Semaphore实现互斥锁Mutex
javayuan的专栏
08-31 5189
    在Doug lea的那本著名的《Java并发编程—设计原则与模式》，英文名"Concurrent Programming in Java™: Design Principles and Patterns, Second Edition"，书中提到可以用信号量Semaphore实现互斥锁Mutex。虽然java中是通过synchronize关键字提供锁，并用这个基础设施实现信号量的。在有的系
分布式锁基于zookeeper实现
mark's technic world
04-22 873
public class LockUtil { private static final Logger logger = LoggerFactory.getLogger(LockUtil.class); private static final byte[] data = { 0x12, 0x34 }; private static Watcher watche
mutex的四种类型
影音视频技术
09-08 1910
在多线程的程序中，多线程间一般使用mutex对临界区进行互斥。但这依赖于各线程的协同约定为进入临界区前都必须加锁，而退出临界区前必须解锁，只要其中的一个线程不遵循这个约定就无法做到互斥一致。比如一个函数： int func() {      a++;      retrun a; } 要对这个函数进行保护，可以这样做： lock(mutex);
基于zookeeper的分布式lock实现
agapple
09-30 322
背景  继续上一篇文章：http://agapple.iteye.com/blog/1183972 ，项目中需要对分布式任务进行调度，那对应的分布式lock实现在所难免。    这一周，在基于BooleanMutex的基础上，实现了zookeeper的分布式锁，用于控制多进程+多线程的lock控制   算法 可以预先看一下zookeeper的官方文档：    http://zoo...
【线程、锁】什么是AQS(锁分类：自旋锁、共享锁、独占锁、读写锁)
m0_45406092的博客
06-28 3791
文章目录1. 什么是AQS2. AQS底层使用了模板方法模式AQS的简单应用参考 1. 什么是AQS AQS：全称为AbstractQuenedSynchronizer，抽象的队列式同步器，是除了java自带的synchronized关键字之外的锁机制，这个类在java.util.concurrent.locks包。 AQS的核心思想是，如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并将共享资源设置为锁定状态，如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒时锁分配的
「从零单排canal 04」 启动模块deployer源码解析
阿丸笔记
07-05 766
基于1.1.5-alpha版本，具体源码笔记可以参考我的github：https://github.com/saigu/JavaKnowledgeGraph/tree/master/code_reading/canal 本文将对canal的启动模块deployer进行分析。 Deployer模块(绿色部分)在整个系统中的角色如下图所示，用来启动canal-server. 模块内的类如下： 为了能带着目的看源码，以几个问题开头，带着问题来一起探索deployer模块的源码。 CanalServer启.
使用Boolean类型同步锁引起异常的分析
老紫竹的专栏
07-11 3731
原文地址 http://topic.csdn.net/u/20080710/19/f61cb4db-ddff-4457-a26a-4ea578b0cc6c.html?87447500 http://www.java2000.net/viewthread.jsp?tid=7085 提问：【tteesstt】 public class MyTest { public static voi
CountDownLatch是如何基于AQS实现的？
最新发布
07-27
CountDownLatch 是基于 AbstractQueuedSynchronizer (AQS) 实现的。 AQS 是 Java 并发包中的一个框架，它提供了一种实现同步器的基础框架。CountDownLatch 内部通过继承 AQS 来实现同步功能。 CountDownLatch 继承...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值