Redis实现求交集操作结果缓存的设计方案

18 篇文章 5 订阅

Redis的集合操作

实话说,Redis提供的集合操作是我选择它成为内存数据库的一个主要理由,它弥补了传统关系型数据库在这方面带来的复杂度,使得只需要简单的一个命令就可以完成一个复杂SQL任务,并且交、并、差操作在实际的业务场景中应用非常广泛,比如快速检索出具备一系列标签属性的一个集合,本篇文章将主要介绍对于求交集操作结果缓存的设计方案。

Redis命令

对于set类型,提供了sinter、sinterstore进行交集操作,对于sortedset,提供了zinter、zinterstore进行交集操作。命令十分便捷,对于不保存结果的方法sinter和zinter只需要输入待求交集的集合的key的数组就可以得到求交集后的结果集合,对于保存结果的方法,你可以将求交集后的结果集合保存到你指定key的一个集合中。

设计方案

目标

计算给定集合群的交集集合,并对计算过程中所产生的中间结果集合进行缓存,从而达到下次计算给定集合群的一些子群集时,先查询是否存在交集key,如果存在直接读取,避免重复计算。

原始方法(Only)

以下我们以Redis Java客户端库Jedis进行举例,Jedis提供了与Redis命令的一致接口方法,实现了交集操作,如下代码:

public Set<String> inter(String[] keys, String keycached){
        int size = keys.length;
        Jedis jedis = new Jedis("127.0.0.1");
        if(size < 2){
            try{
                return jedis.smembers(keys[0]);
            } finally {
                jedis.close();
            }
        }

        try{
            jedis.sinterstore(keycached, keys);
            return jedis.smembers(keycached);
        } finally {
            jedis.close();
        }

    }

原始方法的问题在于只对最终的交集key进行了缓存,简洁方便,但每次变更给定集合群时,都需要重新在此计算。

原始方法上的改造方案(All)

在原始方法上进行改造,我们可以在计算过程中依次增加计算集合群的集合数量,比如给定的集合群key{A,B,C,D},我们先计算A、B,保存一个{A,B}的交集结果,再依次计算A、B、C和A、B、C、D并对结果进行保存。
显然,这是个糟糕的方案,但确实完成了我们设定的目标,参考代码如下:

private Set<String> interByAll(String... keys){
        Jedis jedis = new Jedis("127.0.0.1");
        Set<String> value = null;
        int interNum = 2;
        for(int i = 0; i < (keys.length - 1); i++){
            String keystored = "";
            String[] keyintered = new String[interNum];
            for(int j = 0; j < interNum; j++){
                keystored += (keys[j] + "&");
                keyintered[j] = keys[j];
            }
            if(jedis.sinterstore(keystored, keyintered) == 0){
                jedis.sadd(keystored, "nocache");
            }
            if(interNum == keys.length){
                value = jedis.smembers(keystored);
            }
            interNum++;
        }
        jedis.close();
        return value;
    }

递归方案(Recursive)

根据上面糟糕的设计方案,你应该改进实现一种递归方案,递归方案的好处是你每次只求一对集合的交集,逐步完成对整个给定集合群的交集计算,计算过程如下图所示:

这里写图片描述

    private boolean isEnd = false;
    private Set<String> value = null;
    private Set<String> getKeysWithInner(String[] keys, String srckey, Jedis jedis, int i){

        String key = null;

        if(srckey == null){//表示为第一次求交集
            srckey = keys[i++];
            key = keys[i++];

        } else {
            key = keys[i++];
        }

        String keystored = srckey + "&" + key;//生成缓存key


        if(jedis.sinterstore(keystored, srckey, key) == 0){
            jedis.sadd(keystored, "nocache");
        }

        if(i == keys.length){ //当与最后一个key求交集后,返回结果,并跳出递归调用
            value = jedis.smembers(keystored);
            isEnd = true;
        }

        while(!isEnd){//递归调用,一对key集合求交集
            getKeysWithInner(keys, keystored, jedis, i);
        }

        return value;

    }


    public Set<String> interByRecursive(String... keys){
        int size = keys.length;
        Jedis jedis = new Jedis("127.0.0.1");
        if(size < 2){
            try{
                return jedis.smembers(keys[0]);
            } finally {
                jedis.close();
            }
        }

        try{

            return getKeysWithInner(keys, null, jedis, 0);
        } finally {
            isEnd = false;
            jedis.close();
        }

    }

该方案的优势不仅仅是对计算过程进行了缓存,而且,每次都只是完成一对集合的计算,计算量显著降低。

Fork-Join方案(Fork-Join)

一写递归方案,你就可以直接想到使用Fork-Join框架进行改造,并使其并行化,计算过程如下图所示:

这里写图片描述

InterTask类:

public class InterTask extends RecursiveTask<String>{
    private String[] keys = null;
    private static final int THRESHOLD = 3;
    public InterTask(String[] keys){
        this.keys = keys;
    }

    private static String genKeyinnered(String... keys){
        StringBuilder sb = new StringBuilder();
        for(String key : keys){
            sb.append(key);
            sb.append("&");
        }
        return sb.toString().substring(0, sb.length() - 1);
    }

    @Override
    protected String compute() {
        int size = keys.length;

        if(size < THRESHOLD){//当keys数组中元素数为2个或1个时,计算交集,并退出递归

            if(size < 2){
                return keys[0];
            }
            Jedis jedis = new Jedis("127.0.0.1");
            try{
                jedis.sinterstore(genKeyinnered(keys), keys[0], keys[1]);
            } finally {
                jedis.close();
            }
            return genKeyinnered(keys);

        } else {
            //取keys数组的中值进行分治算法
            String[] leftkeys = new String[size / 2];
            String[] rightkeys = new String[size - (size / 2)];
            //按中值拆分keys数组
            for(int i = 0; i < size; i++){
                if(i < leftkeys.length){
                    leftkeys[i] = keys[i];
                } else {
                    rightkeys[i - leftkeys.length] =  keys[i];
                }
            }


            InterTask lefttask = new InterTask(leftkeys);
            InterTask righttask = new InterTask(rightkeys);

            lefttask.fork();
            righttask.fork();

            //取得从递归中返回的一对存储交集结果的key
            String left = lefttask.join();
            String right = righttask.join();
            Jedis jedis = new Jedis("127.0.0.1");
            try{
                jedis.sinterstore(left + "&" + right, left, right);
            } finally {
                jedis.close();
            }

            return left + "&" + right;
        }


    }

}

这里运用了最基础的分治算法思想,逐步将一个大的给定集合拆解为若干个成对的集合进行交集计算。
调用方法:

public Set<String> interByForkJoin(String... keys){
        Set<String> value = null;
        Jedis jedis = new Jedis("127.0.0.1");
        InterTask task = new InterTask(keys);
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        Future<String> result = forkJoinPool.submit(task);
        try {
            String key = result.get();
            value = jedis.smembers(key);

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            jedis.close();
        }

        return value;
    }

测试

测试数据准备

我们这里准备100个集合,每个给定集合包含1000000个元素,参考如下代码:

    Jedis jedis = new Jedis("127.0.0.1");
    jedis.flushAll();
    String token = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    Random rand = new Random();
    String[] keys = new String[100];
    for(int i = 0; i < 100; i++){
        keys[i] = "ct" + i;
        String[] values = new String[1000000];

        for(int j = 0; j < 1000000; j++){
            StringBuilder sb = new StringBuilder();

            for(int k = 0;k < 2; k++){
                sb.append(token.charAt(rand.nextInt(62)));
            }
            values[j] = sb.toString();

        }
        jedis.sadd(keys[i], values);

    }

    jedis.close();

测试结果

我们分别对25、50、75、100的给定集合进行交集计算,测试结果如下:

这里写图片描述

我们可以清楚的看到,All方案是多么的糟糕,剔除All方案的结果:

这里写图片描述

总体来说Only方案和Recursive方案不分伯仲,但在相对较小的给定合集计算场景下,Recursive存在优势,而且其进行了计算过程结果的缓存。
对于Fork-Join方案表示比较遗憾,当然这里可以采用另外一种更优的分解算法完成并行过程,但是就Redis本身作为通过单线程epoll模型实现的异步IO来说,可能客户端的并行计算在服务端仍然被串行化处理,另外,分治算法拆分数组的时间损耗也不能忽略。

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值