微服务设计指导-让Redis循环写入时提高10倍的技巧

Posted TGITCIC

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了微服务设计指导-让Redis循环写入时提高10倍的技巧相关的知识,希望对你有一定的参考价值。

简介

有微服务的架构不代表性能好,而使用微服务的架构必须要求性能好。这句话不矛盾。矛盾在外面很多人认为微服务架构代表高并发,实际不是。我们有“书面微服务”和“实际微服务”之说。比如说网上大量教人把httpConnection或者是FeignClient的timeout改成30秒就不会超时了?那这要什么微服务呢?微服务解决的到底是什么呢?

绝大多数人忘记了微服务的本质是用来解决什么问题的。

互联网应用在To C端有6秒之说,即一个小程序/APP应用打开和加载过程>6秒,肯定新用户就不会再去用了,4秒算平均水平,一般大厂都是做到加载页面1秒。

各位要知道,任何一个“查询”式页面打开一秒,全站可能存在上千、上万个API,有时一个页面是需要通过几十个API组合在一起的。因此对于API在系统内我们互联网界的要求是约束在“一根API需要在前端万级并发的情况下+系统每张单表千万数据的Data Volumn下响应时间在100毫秒之内的“。

这就是1秒说的由来。

  • To C端界面加载1秒;
  • 任何微服务(即时响应类)要在100毫秒内

这是因为,你的应用上会有不少外联、不少回调、不少地图、配送、支付这种调用。它们都会对我们的应用造成“级联式雪崩”。

为了避免复杂系统的雪崩就需要及时“熔断、限流、升降级”。这就是微服务的本质。

如果已经用了微服务架构、实际发觉这边老是超时,于是很多人一味的去放长这个连接时间自以为就解决了。

这样的人群占比大概超过90%(业界有统计)。

因此用了微服务即代表着对于开发的技能要求水平更高,任何可以提高100毫秒的地方都值得去做。

微服务架构里特别强调一个哲理“勿以善小而不为之,忽以恶小而为之”。

Redis在for循环里写大量数据的梗

通常情况我们经常会碰到要把千、万条数据一次写入Redis,在互联网应用场景中,我们经常把百万、千万级数据也会往Redis里塞,如:Redis Bloom。

经典的写法都是以下这样的:

@Test
    public void testForLoopAddSingleString() throws Exception 
        long startTime = System.currentTimeMillis();
        String redisValue = "";
        for (int i = 0; i < 10000; i++) 
            StringBuilder redisKey = new StringBuilder();
            redisKey.append("key_").append(i);
            redisValue = String.valueOf(i);
            redisTemplate.opsForValue().set(redisKey.toString(), redisValue);
        
        long endTime = System.currentTimeMillis();
        long costTime = endTime - startTime;
        logger.info(">>>>>>test batch add into redis by using normal for loop spent->" + costTime);

    

 

运行后得到如下输出:

Come on man,这才1万条数据,插入Redis要用4.7秒。

我用的是我一直用于模拟千万级数据量的服务器,这台服务器比公司的生产服务器性能还要好几倍,在这样的服务器性能上插入1万条数据都要4.7秒,生产上我们还要算上读存储出来再写Redis的网络开销,实际只会更慢。这种效率是不能忍受的。

增强版写法-Redis Piepeline写法

我们给Redis在它的“写操作上”,不需要增加任何第三方包,自带一颗“永久有效”写加速器,如下代码:

    @Test
    public void testPipelineAddSingleString() throws Exception 
        RedisSerializer<String> keySerializer = (RedisSerializer<String>)redisTemplate.getKeySerializer();
        RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>)redisTemplate.getValueSerializer();
        long startTime = System.currentTimeMillis();
        redisTemplate.executePipelined((RedisCallback<Object>)pipeLine -> 
            try 
                String redisValue = "";
                for (int i = 0; i < 10000; i++) 
                    StringBuilder redisKey = new StringBuilder();
                    redisKey.append("key_").append(i);
                    redisValue = String.valueOf(i);
                    pipeLine.setEx(keySerializer.serialize(redisKey.toString()), 10,
                        valueSerializer.serialize(redisValue));
                
             catch (Exception e) 
                logger.error(">>>>>>test batch add into redis by using pipeline for loop error: " + e.getMessage(), e);
            
            return null;
        );
        long endTime = System.currentTimeMillis();
        long costTime = endTime - startTime;
        logger.info(">>>>>>test batch add into redis by using pipeline for loop spent->" + costTime);
    

大家来看这种写法,你可以认为这种写法和for循环里套着一条条的update table set field=value变成了合并后一个batchUpdate的用法一样。看一下,这种写法带来的效率上的区别吧:

 Oh My God。。。写法上小小一点不同。

4,745毫秒 VS 564毫秒,我算它600毫秒好了,但这得差多少?各位想想。

下面同样给出相应的简单Hash结构的批量写Redis写法

假设我们要往redis里插一个这样的结构的Hash

 

 @Test
    public void testPipelineAddHash() throws Exception 
        RedisSerializer<String> keySerializer = (RedisSerializer<String>)redisTemplate.getKeySerializer();
        RedisSerializer<Object> valueSerializer = (RedisSerializer<Object>)redisTemplate.getValueSerializer();
        long startTime = System.currentTimeMillis();
        String hashKey = "pipeline_hash_key";
        redisTemplate.executePipelined((RedisCallback<Object>)pipeLine -> 
            try 
                String redisValue = "";
                for (int i = 0; i < 10000; i++) 
                    StringBuilder redisKey = new StringBuilder();
                    redisKey.append("key_").append(i);
                    redisValue = String.valueOf(i);
                    pipeLine.hSet(keySerializer.serialize(hashKey), keySerializer.serialize(redisKey.toString()),
                        valueSerializer.serialize(redisValue));
                
             catch (Exception e) 
                logger.error(">>>>>>testPipelineAddHash by using pipeline for loop error: " + e.getMessage(), e);
            
            return null;
        );
        long endTime = System.currentTimeMillis();
        long costTime = endTime - startTime;
        logger.info(">>>>>>testPipelineAddHash by using pipeline for loop spent->" + costTime);
    

 只用了500毫秒左右。

批量往Redis里插入复杂类型Hash的写法

如下,1万个JavaBean以Hash结构存在Redis里。

 

   @Test
    public void testPipelineAddHashBean() throws Exception 
        RedisSerializer<String> keySerializer = (RedisSerializer<String>)redisTemplate.getKeySerializer();
        Jackson2JsonRedisSerializer jacksonSerial = new Jackson2JsonRedisSerializer<>(Object.class);
        long startTime = System.currentTimeMillis();
        String hashKey = "pipeline_hash_key";
        redisTemplate.executePipelined((RedisCallback<Object>)pipeLine -> 
            try 
                String redisValue = "";
                for (int i = 0; i < 10000; i++) 
                    StringBuilder redisKey = new StringBuilder();
                    redisKey.append("key_").append(i);
                    redisValue = String.valueOf(i);
                    UserBean user = new UserBean();
                    user.setUt(redisKey.toString());
                    user.setShareCode(redisValue);
                    pipeLine.hSet(keySerializer.serialize(hashKey), keySerializer.serialize(redisKey.toString()),
                        jacksonSerial.serialize(user));
                
             catch (Exception e) 
                logger.error(">>>>>>testPipelineAddHash by using pipeline for loop error: " + e.getMessage(), e);
            
            return null;
        );
        long endTime = System.currentTimeMillis();
        long costTime = endTime - startTime;
        logger.info(">>>>>>testPipelineAddHash by using pipeline for loop spent->" + costTime);
    

400毫秒左右(有时600毫秒、有时400毫秒、大多情况在400毫秒内)

Redis Bloom过滤器内的类Pipeline写法

同理,往Redis Bloom过滤器里喂值这个量还要大,那么喂入的越快,bloom拦截时的“黑窗期”就越短,对系统越有利。因此它也有同样的批量写入的好方法,如下代码:

    public <T> void addByBloomFilter(BloomFilterHelper<T> bloomFilterHelper, String key, T value) 
        Preconditions.checkArgument(bloomFilterHelper != null, "bloomFilterHelper不能为空");
        int[] offset = bloomFilterHelper.murmurHashOffset(value);
        BitFieldSubCommands commands = BitFieldSubCommands.create();// 使用合并写法,假设10万条数据一个for需要12秒
        for (int i : offset) 
            commands = commands.set(BitFieldSubCommands.BitFieldType.unsigned(1)).valueAt(i).to(1);// 合并bit
        
        redisTemplate.opsForValue().bitField(key, commands);// 再一次写入redis
    

 10万条数据用了45秒

如果用传统写法 如以下代码为传统写法

   public <T> void addByBloomFilterSingleFor(BloomFilterHelper<T> bloomFilterHelper, String key, T value) 
        Preconditions.checkArgument(bloomFilterHelper != null, "bloomFilterHelper不能为空");
        int[] offset = bloomFilterHelper.murmurHashOffset(value);
        for (int i : offset) 
            redisTemplate.opsForValue().setBit(key, i, true);
        
    

10万条数据用了455秒

 总结

回想上一篇我在微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率

中提到过的一个例子:你往百盘网盘里上传3万个每个10K,20K的小文件,要花几小时和把这3万个小文件打包成一个zip一次上传,几分钟就上传好了的梗。

这就是网络I/O读写上因为节省了步骤所带来的致命的效率上的提升。

以上是关于微服务设计指导-让Redis循环写入时提高10倍的技巧的主要内容,如果未能解决你的问题,请参考以下文章

一个让业务开发效率提高10倍的golang库

微服务化最佳实践

DDD专栏7:DDD如何指导微服务设计实现

微服务设计指导-使用云原生微服务解决传统海量跑批时引起的系统间“级联雪崩”以及效率

微服务设计指导-纠正目前网上近90%以上错误的对于“API跨域”问题的所谓指导

Spring Cloud微服务架构实现+Guava缓存+redis+数据库设计+微服务原理改造房产销售