jedis的pipeline、事务等方式

数据库 2018-05-10 04:19:11 阅读次数: 1

转自：http://www.open-open.com/lib/view/open1410485827242.html

jedis是一个著名的key-value存储系统，而作为其官方推荐的java版客户端jedis也非常强大和稳定，支持事务、管道及有jedis自身实现的分布式。

在这里对jedis关于事务、管道和分布式的调用方式做一个简单的介绍和对比：

一、普通同步方式

最简单和基础的调用方式，

1
2
3
4
5
6
7
8
9
10
11
@Test
public  void  test1Normal() {
     Jedis jedis =  new  Jedis( "localhost" );
     long  start = System.currentTimeMillis();
     for  ( int  i =  0 ; i <  100000 ; i++) {
         String result = jedis.set( "n"  + i,  "n"  + i);
     }
     long  end = System.currentTimeMillis();
     System.out.println( "Simple SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     jedis.disconnect();
}

很简单吧，每次set之后都可以返回结果，标记是否成功。

二、事务方式(Transactions)

redis的事务很简单，他主要目的是保障，一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。

看下面例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Test
public  void  test2Trans() {
     Jedis jedis =  new  Jedis( "localhost" );
     long  start = System.currentTimeMillis();
     Transaction tx = jedis.multi();
     for  ( int  i =  0 ; i <  100000 ; i++) {
         tx.set( "t"  + i,  "t"  + i);
     }
     List<Object> results = tx.exec();
     long  end = System.currentTimeMillis();
     System.out.println( "Transaction SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     jedis.disconnect();
}

我们调用jedis.watch(…)方法来监控key，如果调用后key值发生变化，则整个事务会执行失败。另外，事务中某个操作失败，并不会回滚其他操作。这一点需要注意。还有，我们可以使用discard()方法来取消事务。

三、管道(Pipelining)

有时，我们需要采用异步方式，一次发送多个指令，不同步等待其返回结果。这样可以取得非常好的执行效率。这就是管道，调用方法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Test
public  void  test3Pipelined() {
     Jedis jedis =  new  Jedis( "localhost" );
     Pipeline pipeline = jedis.pipelined();
     long  start = System.currentTimeMillis();
     for  ( int  i =  0 ; i <  100000 ; i++) {
         pipeline.set( "p"  + i,  "p"  + i);
     }
     List<Object> results = pipeline.syncAndReturnAll();
     long  end = System.currentTimeMillis();
     System.out.println( "Pipelined SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     jedis.disconnect();
}

四、管道中调用事务

就Jedis提供的方法而言，是可以做到在管道中使用事务，其代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public  void  test4combPipelineTrans() {
     jedis =  new  Jedis( "localhost" ); 
     long  start = System.currentTimeMillis();
     Pipeline pipeline = jedis.pipelined();
     pipeline.multi();
     for  ( int  i =  0 ; i <  100000 ; i++) {
         pipeline.set( ""  + i,  ""  + i);
     }
     pipeline.exec();
     List<Object> results = pipeline.syncAndReturnAll();
     long  end = System.currentTimeMillis();
     System.out.println( "Pipelined transaction: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     jedis.disconnect();
}

但是经测试（见本文后续部分），发现其效率和单独使用事务差不多，甚至还略微差点。

五、分布式直连同步调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Test
public  void  test5shardNormal() {
     List<JedisShardInfo> shards = Arrays.asList(
             new  JedisShardInfo( "localhost" , 6379 ),
             new  JedisShardInfo( "localhost" , 6380 ));
 
     ShardedJedis sharding =  new  ShardedJedis(shards);
 
     long  start = System.currentTimeMillis();
     for  ( int  i =  0 ; i <  100000 ; i++) {
         String result = sharding.set( "sn"  + i,  "n"  + i);
     }
     long  end = System.currentTimeMillis();
     System.out.println( "Simple@Sharing SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
 
     sharding.disconnect();
}

这个是分布式直接连接，并且是同步调用，每步执行都返回执行结果。类似地，还有异步管道调用。

六、分布式直连异步调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Test
public  void  test6shardpipelined() {
     List<JedisShardInfo> shards = Arrays.asList(
             new  JedisShardInfo( "localhost" , 6379 ),
             new  JedisShardInfo( "localhost" , 6380 ));
 
     ShardedJedis sharding =  new  ShardedJedis(shards);
 
     ShardedJedisPipeline pipeline = sharding.pipelined();
     long  start = System.currentTimeMillis();
     for  ( int  i =  0 ; i <  100000 ; i++) {
         pipeline.set( "sp"  + i,  "p"  + i);
     }
     List<Object> results = pipeline.syncAndReturnAll();
     long  end = System.currentTimeMillis();
     System.out.println( "Pipelined@Sharing SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
 
     sharding.disconnect();
}

七、分布式连接池同步调用

如果，你的分布式调用代码是运行在线程中，那么上面两个直连调用方式就不合适了，因为直连方式是非线程安全的，这个时候，你就必须选择连接池调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Test
public  void  test7shardSimplePool() {
     List<JedisShardInfo> shards = Arrays.asList(
             new  JedisShardInfo( "localhost" , 6379 ),
             new  JedisShardInfo( "localhost" , 6380 ));
 
     ShardedJedisPool pool =  new  ShardedJedisPool( new  JedisPoolConfig(), shards);
 
     ShardedJedis one = pool.getResource();
 
     long  start = System.currentTimeMillis();
     for  ( int  i =  0 ; i <  100000 ; i++) {
         String result = one.set( "spn"  + i,  "n"  + i);
     }
     long  end = System.currentTimeMillis();
     pool.returnResource(one);
     System.out.println( "Simple@Pool SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
 
     pool.destroy();
}

上面是同步方式，当然还有异步方式。

八、分布式连接池异步调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Test
public  void  test8shardPipelinedPool() {
     List<JedisShardInfo> shards = Arrays.asList(
             new  JedisShardInfo( "localhost" , 6379 ),
             new  JedisShardInfo( "localhost" , 6380 ));
 
     ShardedJedisPool pool =  new  ShardedJedisPool( new  JedisPoolConfig(), shards);
 
     ShardedJedis one = pool.getResource();
 
     ShardedJedisPipeline pipeline = one.pipelined();
 
     long  start = System.currentTimeMillis();
     for  ( int  i =  0 ; i <  100000 ; i++) {
         pipeline.set( "sppn"  + i,  "n"  + i);
     }
     List<Object> results = pipeline.syncAndReturnAll();
     long  end = System.currentTimeMillis();
     pool.returnResource(one);
     System.out.println( "Pipelined@Pool SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     pool.destroy();
}

九、需要注意的地方

  1. 事务和管道都是异步模式。在事务和管道中不能同步查询结果。比如下面两个调用，都是不允许的：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
      Transaction tx = jedis.multi();
      for  ( int  i =  0 ; i <  100000 ; i++) {
          tx.set( "t"  + i,  "t"  + i);
      }
      System.out.println(tx.get( "t1000" ).get());   //不允许
     
      List<Object> results = tx.exec();
     
      …
      …
     
      Pipeline pipeline = jedis.pipelined();
      long  start = System.currentTimeMillis();
      for  ( int  i =  0 ; i <  100000 ; i++) {
          pipeline.set( "p"  + i,  "p"  + i);
      }
      System.out.println(pipeline.get( "p1000" ).get());  //不允许
     
      List<Object> results = pipeline.syncAndReturnAll();

  2. 事务和管道都是异步的，个人感觉，在管道中再进行事务调用，没有必要，不如直接进行事务模式。

  3. 分布式中，连接池的性能比直连的性能略好(见后续测试部分)。

  4. 分布式调用中不支持事务。

    因为事务是在服务器端实现，而在分布式中，每批次的调用对象都可能访问不同的机器，所以，没法进行事务。

十、测试

运行上面的代码，进行测试，其结果如下：

1
2
3
4
5
6
7
8
9
10
11
Simple SET:  5.227  seconds
 
Transaction SET:  0.5  seconds
Pipelined SET:  0.353  seconds
Pipelined transaction:  0.509  seconds
 
Simple @Sharing  SET:  5.289  seconds
Pipelined @Sharing  SET:  0.348  seconds
 
Simple @Pool  SET:  5.039  seconds
Pipelined @Pool  SET:  0.401  seconds

另外，经测试分布式中用到的机器越多，调用会越慢。上面是2片，下面是5片：

1
2
3
4
Simple @Sharing  SET:  5.494  seconds
Pipelined @Sharing  SET:  0.51  seconds
Simple @Pool  SET:  5.223  seconds
Pipelined @Pool  SET:  0.518  seconds

下面是10片：

1
2
3
4
Simple @Sharing  SET:  5.9  seconds
Pipelined @Sharing  SET:  0.794  seconds
Simple @Pool  SET:  5.624  seconds
Pipelined @Pool  SET:  0.762  seconds

下面是100片：

1
2
3
4
Simple @Sharing  SET:  14.055  seconds
Pipelined @Sharing  SET:  8.185  seconds
Simple @Pool  SET:  13.29  seconds
Pipelined @Pool  SET:  7.767  seconds

分布式中，连接池方式调用不但线程安全外，根据上面的测试数据，也可以看出连接池比直连的效率更好。

十一、完整的测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
package  com.example.nosqlclient;
 
import  java.util.Arrays;
import  java.util.List;
 
import  org.junit.AfterClass;
import  org.junit.BeforeClass;
import  org.junit.Test;
 
import  redis.clients.jedis.Jedis;
import  redis.clients.jedis.JedisPoolConfig;
import  redis.clients.jedis.JedisShardInfo;
import  redis.clients.jedis.Pipeline;
import  redis.clients.jedis.ShardedJedis;
import  redis.clients.jedis.ShardedJedisPipeline;
import  redis.clients.jedis.ShardedJedisPool;
import  redis.clients.jedis.Transaction;
 
import  org.junit.FixMethodOrder;
import  org.junit.runners.MethodSorters;
 
@FixMethodOrder (MethodSorters.NAME_ASCENDING)
public  class  TestJedis {
 
     private  static  Jedis jedis;
     private  static  ShardedJedis sharding;
     private  static  ShardedJedisPool pool;
 
     @BeforeClass
     public  static  void  setUpBeforeClass()  throws  Exception {
         List<JedisShardInfo> shards = Arrays.asList(
                 new  JedisShardInfo( "localhost" , 6379 ),
                 new  JedisShardInfo( "localhost" , 6379 ));  //使用相同的ip:port,仅作测试
 
 
         jedis =  new  Jedis( "localhost" ); 
         sharding =  new  ShardedJedis(shards);
 
         pool =  new  ShardedJedisPool( new  JedisPoolConfig(), shards);
     }
 
     @AfterClass
     public  static  void  tearDownAfterClass()  throws  Exception {
         jedis.disconnect();
         sharding.disconnect();
         pool.destroy();
     }
 
     @Test
     public  void  test1Normal() {
         long  start = System.currentTimeMillis();
         for  ( int  i =  0 ; i <  100000 ; i++) {
             String result = jedis.set( "n"  + i,  "n"  + i);
         }
         long  end = System.currentTimeMillis();
         System.out.println( "Simple SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     }
 
     @Test
     public  void  test2Trans() {
         long  start = System.currentTimeMillis();
         Transaction tx = jedis.multi();
         for  ( int  i =  0 ; i <  100000 ; i++) {
             tx.set( "t"  + i,  "t"  + i);
         }
         //System.out.println(tx.get("t1000").get());
 
         List<Object> results = tx.exec();
         long  end = System.currentTimeMillis();
         System.out.println( "Transaction SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     }
 
     @Test
     public  void  test3Pipelined() {
         Pipeline pipeline = jedis.pipelined();
         long  start = System.currentTimeMillis();
         for  ( int  i =  0 ; i <  100000 ; i++) {
             pipeline.set( "p"  + i,  "p"  + i);
         }
         //System.out.println(pipeline.get("p1000").get());
         List<Object> results = pipeline.syncAndReturnAll();
         long  end = System.currentTimeMillis();
         System.out.println( "Pipelined SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     }
 
     @Test
     public  void  test4combPipelineTrans() {
         long  start = System.currentTimeMillis();
         Pipeline pipeline = jedis.pipelined();
         pipeline.multi();
         for  ( int  i =  0 ; i <  100000 ; i++) {
             pipeline.set( ""  + i,  ""  + i);
         }
         pipeline.exec();
         List<Object> results = pipeline.syncAndReturnAll();
         long  end = System.currentTimeMillis();
         System.out.println( "Pipelined transaction: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     }
 
     @Test
     public  void  test5shardNormal() {
         long  start = System.currentTimeMillis();
         for  ( int  i =  0 ; i <  100000 ; i++) {
             String result = sharding.set( "sn"  + i,  "n"  + i);
         }
         long  end = System.currentTimeMillis();
         System.out.println( "Simple@Sharing SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     }
 
     @Test
     public  void  test6shardpipelined() {
         ShardedJedisPipeline pipeline = sharding.pipelined();
         long  start = System.currentTimeMillis();
         for  ( int  i =  0 ; i <  100000 ; i++) {
             pipeline.set( "sp"  + i,  "p"  + i);
         }
         List<Object> results = pipeline.syncAndReturnAll();
         long  end = System.currentTimeMillis();
         System.out.println( "Pipelined@Sharing SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     }
 
     @Test
     public  void  test7shardSimplePool() {
         ShardedJedis one = pool.getResource();
 
         long  start = System.currentTimeMillis();
         for  ( int  i =  0 ; i <  100000 ; i++) {
             String result = one.set( "spn"  + i,  "n"  + i);
         }
         long  end = System.currentTimeMillis();
         pool.returnResource(one);
         System.out.println( "Simple@Pool SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     }
 
     @Test
     public  void  test8shardPipelinedPool() {
         ShardedJedis one = pool.getResource();
 
         ShardedJedisPipeline pipeline = one.pipelined();
 
         long  start = System.currentTimeMillis();
         for  ( int  i =  0 ; i <  100000 ; i++) {
             pipeline.set( "sppn"  + i,  "n"  + i);
         }
         List<Object> results = pipeline.syncAndReturnAll();
         long  end = System.currentTimeMillis();
         pool.returnResource(one);
         System.out.println( "Pipelined@Pool SET: "  + ((end - start)/ 1000.0 ) +  " seconds" );
     }
}

猜你喜欢

转载自zfy421.iteye.com/blog/2274335
今日推荐
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
周排行
curl的POST请求，封装方法
8.1.1. Integer Types
Java基础 Day05(个人复习整理)
Python - Django - 中间件 process_exception
小L的试卷
【Shell编程】 （函数）判断用户是否存在
python(css样式)
spring ant path 匹配原则 - 【笔记】
《JavaScript与JScript从入门到精通》(美)James.Jaworski.中译本.扫描版.pdf
Eclipse运行带参数的java程序
每日归档
更多
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022