一般情况下，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测试了一下：

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

测试结果如下：

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

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