一般情况下,大家使用redis去put/get都是先拿到一个jedis实例,然后操作,然后释放连接;这种模式是

请求-响应,请求-响应

这种模式,下一次请求必须得等第一次请求响应回来之后才可以,因为redis是单线程的,按部就班,一步一步来。

而pipeline管道改变了这种请求模式,客户端可以一次发送多个命令,无须等待服务器的返回,

请求,请求,请求,响应,响应,响应

这种模式

这就大大减少了影响性能的关键因素-网络往返时间

下面就上面两种模式以及JDK的map三者做一个性能比较

  1.  
    package redis;
  2.  
     
  3.  
    import java.util.concurrent.BlockingQueue;
  4.  
    import java.util.concurrent.LinkedBlockingQueue;
  5.  
     
  6.  
    import redis.clients.jedis.ShardedJedis;
  7.  
    import redis.clients.jedis.ShardedJedisPipeline;
  8.  
     
  9.  
    /**
  10.  
    * @Type ShardRedisDemo.java
  11.  
    * @Desc
  12.  
    * @author chiwei
  13.  
    * @date 2016年6月13日 下午3:24:25
  14.  
    * @version
  15.  
    */
  16.  
    public class ShardRedisDemo {
  17.  
     
  18.  
    public static void main(String[] args) throws InterruptedException {
  19.  
    ShardRedisClient src = new ShardRedisClient();
  20.  
    src.setServers("redis://172.23.26.135:7379");
  21.  
    src.init();
  22.  
    int count = 10000;
  23.  
    ShardedJedis sj = src.getResource();
  24.  
    long begin = System.currentTimeMillis();
  25.  
    for (int i = 0; i < count; i++) {
  26.  
    sj.set("a" + i, "v" + i);
  27.  
    }
  28.  
    sj.close();
  29.  
    System.out.println(System.currentTimeMillis() - begin);
  30.  
    sj = src.getResource();
  31.  
    ShardedJedisPipeline p = sj.pipelined();
  32.  
    begin = System.currentTimeMillis();
  33.  
    for (int i = 0; i < count; i++) {
  34.  
    p.set("ap" + i, "vp" + i);
  35.  
    }
  36.  
    p.sync();
  37.  
    sj.close();
  38.  
    System.out.println(System.currentTimeMillis() - begin);
  39.  
    BlockingQueue<String> logQueue = new LinkedBlockingQueue<String>();
  40.  
    begin = System.currentTimeMillis();
  41.  
    for (int i = 0; i < count; i++) {
  42.  
    logQueue.put("i=" + i);
  43.  
    }
  44.  
    System.out.println(System.currentTimeMillis() - begin);
  45.  
    }
  46.  
     
  47.  
    }
  48.  
     
  49.  
    /**
  50.  
    * Revision history
  51.  
    * -------------------------------------------------------------------------
  52.  
    *
  53.  
    * Date Author Note
  54.  
    * -------------------------------------------------------------------------
  55.  
    * 2016年6月13日 chiwei create
  56.  
    */

结果如下:

45027
116
11

大家看相对时间就行了,我测试时是经过VPN连的redis,由此结果可见pipeline的性能惊人的高。

但是pipeline适合于什么样的场景使用呢?

有些系统可能对可靠性要求很高,每次操作都需要立马知道这次操作是否成功,是否数据已经写进redis了,那这种场景就不适合。

还有的系统,可能是批量的将数据写入redis,允许一定比例的写入失败,那么这种场景就可以使用了,比如10000条一下进入redis,可能失败了2条无所谓,后期有补偿机制就行了,比如短信群发这种场景,如果一下群发10000条,按照第一种模式去实现,那这个请求过来,要很久才能给客户端响应,这个延迟就太长了,如果客户端请求设置了超时时间5秒,那肯定就抛出异常了,而且本身群发短信要求实时性也没那么高,这时候用pipeline最好了。

=======================================================================================================================

一般情况下,Redis Client端发出一个请求后,通常会阻塞并等待Redis服务端处理,Redis服务端处理完后请求命令后会将结果通过响应报文返回给Client。
这有点类似于HBase的Scan,通常是Client端获取每一条记录都是一次RPC调用服务端。
在Redis中,有没有类似HBase Scanner Caching的东西呢,一次请求,返回多条记录呢?
有,这就是Pipline。官方介绍 http://redis.io/topics/pipelining

通过pipeline方式当有大批量的操作时候,我们可以节省很多原来浪费在网络延迟的时间,需要注意到是用pipeline方式打包命令发送,redis必须在处理完所有命令前先缓存起所有命令的处理结果。打包的命令越多,缓存消耗内存也越多。所以并不是打包的命令越多越好。

使用Pipeline在对Redis批量读写的时候,性能上有非常大的提升。

使用Java测试了一下:

  1. package com.lxw1234.redis;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. import java.util.Set;
  5. import redis.clients.jedis.Jedis;
  6. import redis.clients.jedis.Pipeline;
  7. import redis.clients.jedis.Response;
  8. public class Test {
  9. public static void main(String[] args) throws Exception {
  10. Jedis redis = new Jedis("127.0.0.1", 6379, 400000);
  11. Map<String,String> data = new HashMap<String,String>();
  12. redis.select(8);
  13. redis.flushDB();
  14. //hmset
  15. long start = System.currentTimeMillis();
  16. //直接hmset
  17. for (int i=0;i<10000;i++) {
  18. data.clear();
  19. data.put("k_" + i, "v_" + i);
  20. redis.hmset("key_" + i, data);
  21. }
  22. long end = System.currentTimeMillis();
  23. System.out.println("dbsize:[" + redis.dbSize() + "] .. ");
  24. System.out.println("hmset without pipeline used [" + (end - start) / 1000 + "] seconds ..");
  25. redis.select(8);
  26. redis.flushDB();
  27. //使用pipeline hmset
  28. Pipeline p = redis.pipelined();
  29. start = System.currentTimeMillis();
  30. for (int i=0;i<10000;i++) {
  31. data.clear();
  32. data.put("k_" + i, "v_" + i);
  33. p.hmset("key_" + i, data);
  34. }
  35. p.sync();
  36. end = System.currentTimeMillis();
  37. System.out.println("dbsize:[" + redis.dbSize() + "] .. ");
  38. System.out.println("hmset with pipeline used [" + (end - start) / 1000 + "] seconds ..");
  39. //hmget
  40. Set keys = redis.keys("*");
  41. //直接使用Jedis hgetall
  42. start = System.currentTimeMillis();
  43. Map<String,Map<String,String>> result = new HashMap<String,Map<String,String>>();
  44. for(String key : keys) {
  45. result.put(key, redis.hgetAll(key));
  46. }
  47. end = System.currentTimeMillis();
  48. System.out.println("result size:[" + result.size() + "] ..");
  49. System.out.println("hgetAll without pipeline used [" + (end - start) / 1000 + "] seconds ..");
  50. //使用pipeline hgetall
  51. Map<String,Response<Map<String,String>>> responses = new HashMap<String,Response<Map<String,String>>>(keys.size());
  52. result.clear();
  53. start = System.currentTimeMillis();
  54. for(String key : keys) {
  55. responses.put(key, p.hgetAll(key));
  56. }
  57. p.sync();
  58. for(String k : responses.keySet()) {
  59. result.put(k, responses.get(k).get());
  60. }
  61. end = System.currentTimeMillis();
  62. System.out.println("result size:[" + result.size() + "] ..");
  63. System.out.println("hgetAll with pipeline used [" + (end - start) / 1000 + "] seconds ..");
  64. redis.disconnect();
  65. }
  66. }

测试结果如下:

  1. dbsize:[10000] ..
  2. hmset without pipeline used [243] seconds ..
  3. dbsize:[10000] ..
  4. hmset with pipeline used [0] seconds ..
  5. result size:[10000] ..
  6. hgetAll without pipeline used [243] seconds ..
  7. result size:[10000] ..
  8. hgetAll with pipeline used [0] seconds ..

使用pipeline来批量读写10000条记录,就是小菜一碟,秒完。

转自:https://blog.csdn.net/simonchi/article/details/52231674

转自:https://www.cnblogs.com/an7ing/p/5082243.html

Java Redis的Pipeline管道,批量操作,节省大量网络往返时间 & Redis批量读写(hmset&hgetall) 使用Pipeline的更多相关文章

  1. 【JAVA今法修真】 第三章 关系非关系 redis法器

    您好,我是南橘,万法仙门的掌门,刚刚从九州世界穿越到地球,因为时空乱流的影响导致我的法力全失,现在不得不通过这个平台向广大修真天才们借去力量.你们的每一个点赞,每一个关注都是让我回到九州世界的助力,兄 ...

  2. Python高级编程之生成器(Generator)与coroutine(三):coroutine与pipeline(管道)和Dataflow(数据流_

    原创作品,转载请注明出处:点我 在前两篇文章中,我们介绍了什么是Generator和coroutine,在这一篇文章中,我们会介绍coroutine在模拟pipeline(管道 )和控制Dataflo ...

  3. 【spring boot】spring boot 基于redis pipeline 管道,批量操作redis命令

    spring boot 2.x 使用RedisTemplate 操作 =================================== 1.pom.xml <!--spring2.0集成r ...

  4. 【redis】pipeline - 管道模型

    redis-pipeline 2020-02-10: 因为我把github相关的wiki删了,所以导致破图...待解决.(讲真github-wiki跟project是2个url,真的不好用) 因为用的 ...

  5. .NET客户端实现Redis中的管道(PipeLine)与事物(Transactions)

    序言 Redis中的管道(PipeLine)特性:简述一下就是,Redis如何从客户端一次发送多个命令,服务端到客户端如何一次性响应多个命令. Redis使用的是客户端-服务器模型和请求/响应协议的T ...

  6. Java 使用pipeline对redis进行批量读写

    code import redis.clients.jedis.Jedis; import redis.clients.jedis.Pipeline; import java.util.List; p ...

  7. 使用pipeline管道执行redis命令

    pipeline管道可以减少后端与redis的连接次数,从而实现了优化. 原理如下: 使用方法: 未使用pipeline前: strict_redis = get_redis_connection(' ...

  8. Redis中的管道(PipeLine)与事物(Transactions)

    Redis中的管道(PipeLine)与事物(Transactions) 序言 Redis中的管道(PipeLine)特性:简述一下就是,Redis如何从客户端一次发送多个命令,服务端到客户端如何一次 ...

  9. Redis六(管道)

    管道 为什么使用管道? Redis是一个TCP服务器,支持请求/响应协议. 在Redis中,请求通过以下步骤完成: 客户端向服务器发送查询,并从套接字读取,通常以阻塞的方式,用于服务器响应. 服务器处 ...

随机推荐

  1. Oracle数据类型number

    oracle数值类型只有number number(变长) 1.number可以存放整数,可以存放小数: 2.number(p,s) 说明: p表示有效位,s为小数位:范围p[1,38],s[-84, ...

  2. scrapy爬虫系列之五--CrawlSpider的使用

    功能点:CrawlSpider的基本使用 爬取网站:保监会 主要代码: cf.py # -*- coding: utf-8 -*- import scrapy from scrapy.linkextr ...

  3. collectionView itemW宽度计算不对

    ([[UIScreen mainScreen] bounds].size.width - 28) / 4.00 没加括号 collectioView不能正常撑开 用flowLayout 不要用 代理方 ...

  4. Buy Tickets---poj2828(线段树)

    题目链接:http://poj.org/problem?id=2828 题意就是有n个x y每次都是把y放到x位置,如果x位置有数,则把该位置之后的数往后放一位: [题解]: 线段树节点中保存这一段中 ...

  5. Python总结篇——知识大全

    python基础 Python开发环境搭建 Python变量和基本数据类型 python基本数据类型之操作 python的语法规范及for和while python编码 python文件操作 pyth ...

  6. python 面向对象 公有属性

    公有属性定义  公有属性也叫作类变量  静态字段 class role(): # 传参数 # 公有属性都在这里定义 # 在类里直接定义的属性即是公有属性 nationality = 'JP' def ...

  7. ReactiveCocoa 初学者使用

    skip 跳过几个信号,不接受 filter :过滤 ignore:忽略某一个值 take:从开始一共取N次的信号 ignoreValues 这个比较极端,忽略所有值,只关心Signal结束,也就是只 ...

  8. EOS 的网站及资料doc

    https://github.com/EOSIO/Documentation/blob/master/zh-CN/Roadmap.md https://bytemaster.github.io/bit ...

  9. mybatis 中jdbctype和javatype的对应关系

    1:mybatis 中jdbctype和javatype的对应关系 JDBC Type Java Type CHAR String VARCHAR String LONGVARCHAR String ...

  10. selenium自我手册

    (转载需注明原文地址和作者两项,否则视为非授权) 语言:python 0x00 预热 下载安装包 pip install selenium 确定所用的浏览器 支持firefox,chrome,IE,e ...