zoukankan      html  css  js  c++  java
  • 【转】 SpringBoot(18)---通过Lua脚本批量插入数据到Redis布隆过滤器

    【转】 SpringBoot(18)---通过Lua脚本批量插入数据到Redis布隆过滤器

    通过Lua脚本批量插入数据到布隆过滤器

    有关布隆过滤器的原理之前写过一篇博客: 算法(3)---布隆过滤器原理

    在实际开发过程中经常会做的一步操作,就是判断当前的key是否存在。

    那这篇博客主要分为三部分:

    1、几种方式判断当前key是否存在的性能进行比较。
    2、Redis实现布隆过滤器并批量插入数据,并判断当前key值是否存在。
    3、针对以上做一个总结。
    

    一、性能对比

    主要对以下方法进行性能测试比较:

    1、List的 contains 方法

    2、Map的 containsKey 方法

    3、Google布隆过滤器 mightContain 方法

    前提准备

    在SpringBoot项目启动的时候,向 List集合Map集合Google布隆过滤器 分布存储500万条,长度为32位的String字符串。

    1、演示代码

    @Slf4j
    @RestController
    public class PerformanceController {
    
        /**
         * 存储500万条数据
         */
        public static final int SIZE = 5000000;
        /**
         * list集合存储数据
         */
        public static List<String> list = Lists.newArrayListWithCapacity(SIZE);
        /**
         * map集合存储数据
         */
        public static Map<String, Integer> map = Maps.newHashMapWithExpectedSize(SIZE);
        /**
         * guava 布隆过滤器
         */
        BloomFilter<String> bloomFilter = BloomFilter.create(Funnels.unencodedCharsFunnel(), SIZE);
        /**
         * 用来校验的集合
         */
        public static List<String> exist = Lists.newArrayList();
        /**
         * 计时工具类
         */
        public static Stopwatch stopwatch = Stopwatch.createUnstarted();
    
        /**
         * 初始化数据
         */
        @PostConstruct
        public void insertData() {
            for (int i = 0; i < SIZE; i++) {
                String data = UUID.randomUUID().toString();
                data = data.replace("-", "");
                //1、存入list
                list.add(data);
                //2、存入map
               map.put(data, 0);
                //3、存入本地布隆过滤器
                bloomFilter.put(data);
                //校验数据 相当于从这500万条数据,存储5条到这个集合中
                if (i % 1000000 == 0) {
                    exist.add(data);
                }
            }
        }
        /**
         * 1、list 查看value是否存在 执行时间
         */
        @RequestMapping("/list")
        public void existsList() {
            //计时开始
            stopwatch.start();
            for (String s : exist) {
                if (list.contains(s)) {
                    log.info("list集合存在该数据=============数据{}", s);
                }
            }
            //计时结束
            stopwatch.stop();
            log.info("list集合测试,判断该元素集合中是否存在用时:{}", stopwatch.elapsed(MILLISECONDS));
            stopwatch.reset();
        }
        /**
         * 2、查看map 判断k值是否存在 执行时间
         */
        @RequestMapping("/map")
        public void existsMap() {
            //计时开始
            stopwatch.start();
            for (String s : exist) {
                if (map.containsKey(s)) {
                    log.info("map集合存在该数据=============数据{}", s);
                }
            }
            //计时结束
            stopwatch.stop();
            //获取时间差
    
            log.info("map集合测试,判断该元素集合中是否存在用时:{}", stopwatch.elapsed(MILLISECONDS));
            stopwatch.reset();
        }
    
        /**
         * 3、查看guava布隆过滤器 判断value值是否存在 执行时间
         */
        @RequestMapping("/bloom")
        public void existsBloom() {
            //计时开始
            stopwatch.start();
            for (String s : exist) {
            if (bloomFilter.mightContain(s)) {
                log.info("guava布隆过滤器存在该数据=============数据{}", s);
            }
            }
            //计时结束
            stopwatch.stop();
            //获取时间差
            log.info("bloom集合测试,判断该元素集合中是否存在用时:{}", stopwatch.elapsed(MILLISECONDS));
            stopwatch.reset();
        }
    }
    

    2、测试输出结果

    测试结果

    这里其实对每一个校验是否存在的方法都执行了5次,如果算单次的话那么,那么在500万条数据,且每条数据长度为32位的String类型情况下,可以大概得出。

    1、List的contains方法执行所需时间,大概80毫秒左右。
    2、Map的containsKey方法执行所需时间,不超过1毫秒。
    3、Google布隆过滤器 mightContain 方法,不超过1毫秒。
    

    总结

    Map比List效率高的原因这里就不用多说,没有想到的是它们速度都这么快。我还测了100万条数据通过list遍历key时间竟然也不超过1毫秒。这说明在实际开发过程中,如果数据

    量不大的话,用哪里其实都差不多。

    3、占用内存分析

    从上面的执行效率来看,Google布隆过滤器 其实没什么优势可言,确实如果数据量小,完全通过上面就可以解决,不需要考虑布隆过滤器,但如果数据量巨大,千万甚至亿级

    别那种,用集合肯定不行,不是说执行效率不能接受,而是占内存不能接受。

    我们来算下key值为32字节的500万条条数据,存放在List集合需要占多少内存。

    500万 * 32 = 16000000字节 ≈ 152MB

    一个集合就占这么大内存,这点显然无法接受的。

    那我们来算算布隆过滤器所需要占内存

    • 设bit数组大小为m,样本数量为n,失误率为p。

    • 由题可知 n = 500万,p = 3%(Google布隆过滤器默认为3%,我们也可以修改

      通过公式求得:

    m ≈ 16.7MB

    是不是可以接收多了。

    那么Google布隆过滤器也有很大缺点

    1、每次项目启动都要重新将数据存入Google布隆过滤器,消费额外的资源。
    2、分布式集群部署架构中,需要在每个集群节点都要存储一份相同数据到布隆过滤器中。
    3、随着数据量的加大,布隆过滤器也会占比较大的JVM内存,显然也不够合理。
    

    那么有个更好的解决办法,就是用redis作为分布式集群的布隆过滤器。

    二、Redis布隆过滤器

    1、Redis服务器搭建

    如果你不是用docker,那么你需要先在服务器上部署redis,然后单独安装支持redis布隆过滤器的插件rebloom

    如果你用过docker那么部署就非常简单了,只需以下命令:

      docker pull redislabs/rebloom # 拉取镜像
      docker run -p 6379:6379 redislabs/rebloom # 运行容器
    

    这样就安装成功了。

    2、Lua批量插入脚本

    SpringBoot完整代码我这里就不粘贴出来了,文章最后我会把整个项目的github地址附上,这里就只讲下脚本的含义:

    bloomFilter-inster.lua

    local values = KEYS
    local bloomName = ARGV[1]
    local result_1
    for k,v in ipairs(values) do
     result_1 = redis.call('BF.ADD',bloomName,v)
    end
    return result_1
    

    1)参数说明

    这里的 KEYSARGV[1]都是需要我们在java代码中传入,redisTemplate有个方法

    execute(RedisScript<T> script, List<K> keys, Object... args)
    
    • script实体中中封装批量插入的lua脚本。
    • keys 对于脚本的 KEYS
    • ARGV[1]对于可变参数第一个,如果输入多个可变参数,可以可以通过ARGV[2].....去获取。

    2)遍历

    Lua遍历脚本有两种方式一个是ipairs,另一个是pairs它们还是有差别的。这里也不做展开,下面有篇博客可以参考。

    注意Lua的遍历和java中遍历还有有点区别的,我们java中是从0开始,而对于Lua脚本 k是从1开始的。

    3)插入命令

    BF.ADD 是往布隆过滤器中插入数据的命令,插入成功返回 true

    3、判断布隆过滤器元素是否存在Lua脚本

    bloomFilter-exist.lua

    local bloomName = KEYS[1]
    local value = KEYS[2]
    -- bloomFilter
    local result_1 = redis.call('BF.EXISTS', bloomName, value)
    return result_1
    

    从这里我们可以很明显看到, KEYS[1]对于的是keys集合的get(0)位置,所以说Lua遍历是从1开始的。

    BF.EXISTS 是判断布隆过滤器中是否存在该数据命令,存在返回true

    4、测试

    我们来测下是否成功。

    @Slf4j
    @RestController
    public class RedisBloomFilterController {
    
        @Autowired
        private RedisService redisService;
        public static final String FILTER_NAME = "isMember";
       
        /**
         * 保存 数据到redis布隆过滤器
         */
        @RequestMapping("/save-redis-bloom")
        public Object saveReidsBloom() {
            //数据插入布隆过滤器
            List<String> exist = Lists.newArrayList("11111", "22222");
            Object object = redisService.addsLuaBloomFilter(FILTER_NAME, exist);
            log.info("保存是否成功====object:{}",object);
            return object;
        }
        /**
         * 查询 当前数据redis布隆过滤器是否存在
         */
        @RequestMapping("/exists-redis-bloom")
        public void existsReidsBloom() {
            //不存在输出
            if (!redisService.existsLuabloomFilter(FILTER_NAME, "00000")) {
                log.info("redis布隆过滤器不存在该数据=============数据{}",  "00000");
            }
            //存在输出
            if (redisService.existsLuabloomFilter(FILTER_NAME, "11111")) {
                log.info("redis布隆过滤器存在该数据=============数据{}", "11111");
            }
        }
    }
    

    这里先调插入接口,插入两条数据,如果返回true则说明成功,如果是同一个数据第一次插入返回成功,第二次插入就会返回false,说明重复插入相同值会失败。

    然后调查询接口,这里应该两条日志都会输出,因为上面"00000"是取反的,多了个!号。

    我们来看最终结果。

    符合我们的预期,说明,redis布隆过滤器从部署到整合SpringBoot都是成功的。

    三、总结

    下面个人对整个做一个总结吧。主要是思考下,在什么环境下可以考虑用以上哪种方式来判断该元素是否存在。

    1、数据量不大,且不能有误差。

    那么用List或者Map都可以,虽然说List判断该元素是否存在采用的是遍历集合的方式,在性能在会比Map差,但就像上面测试一样,100万的数据,

    List遍历和Map都不超过1毫秒,选谁不都一样,何必在乎那0.几毫秒的差异。

    2、数据量不大,且允许有误差。

    这就可以考虑用Google布隆过滤器了,尽管查询数据效率都差不多,但关键是它可以减少内存的开销,这就很关键。

    3、数据量大,且不能有误差。

    如果说数量大,为了提升查询元素是否存在的效率,而选用Map的话,我觉得也不对,因为如果数据量大,所占内存也会更大,所以我更推荐用

    Redis的map数据结构来存储数据,这样可以大大减少JVM内存开销,而且不需要每次重启都要往集合中存储数据。

    4、数据量大,且允许有误差。

    如果是单体应用,数据量内存也可以接收,那么可以考虑Google布隆过滤器,因为它的查询速度会比redis要快。毕竟它不需要网络IO开销。

    如果是分布式集群架构,或者数据量非常大,那么还是考虑用redis布隆过滤器吧,毕竟它不需要往每一节点都存储数据,而且不占用JVM虚拟机内存。

    Github地址https://github.com/yudiandemingzi/spring-boot-redis-lua

    参考

    1、redis lua官方文档

    2、redis lua中文翻译文档

    3、Lua泛型for遍历table时ipairs与pairs的区别


    只要自己变优秀了,其他的事情才会跟着好起来(上将10)
    
  • 相关阅读:
    Python+MySQL学习笔记(一)
    MySQL的基本操作
    2016.08.15
    使用vue为image的src动态赋值
    json对象与json字符串的转化
    js三元运算符
    uniapp vue中的短信验证码
    设计模式
    回调函数
    自定义注解
  • 原文地址:https://www.cnblogs.com/Javastudy-note/p/13818119.html
Copyright © 2011-2022 走看看