阅读目录
- 一、普通同步方式
- 二、事务方式(Transactions)
- 三、管道(Pipelining)
- 四、管道中调用事务
- 五、分布式直连同步调用
- 六、分布式直连异步调用
- 七、分布式连接池同步调用
- 八、分布式连接池异步调用
- 九、需要注意的地方
- 十、测试
- 十一、完整的测试代码
- jedis是一个著名的key-value存储系统，而作为其官方推荐的java版客户端jedis也非常强大和稳定，支持事务、管道及有jedis自身实现的分布式。
在这里对jedis关于事务、管道和分布式的调用方式做一个简单的介绍和对比：
一、普通同步方式
最简单和基础的调用方式，
|
1
2
3
4
5
6
7
8
9
10
11
|
@Testpublic 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
|
@Testpublic 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
|
@Testpublic 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
|
@Testpublic 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
|
@Testpublic 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
|
@Testpublic 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
|
@Testpublic 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();
} |
上面是同步方式，当然还有异步方式。
八、分布式连接池异步调用
|
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
@Testpublic 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();
} |
九、需要注意的地方
-
事务和管道都是异步模式。在事务和管道中不能同步查询结果。比如下面两个调用，都是不允许的：
12345678910111213141516171819Transaction tx = jedis.multi();for(inti =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();longstart = System.currentTimeMillis();for(inti =0; i <100000; i++) {pipeline.set("p"+ i,"p"+ i);}System.out.println(pipeline.get("p1000").get());//不允许List<Object> results = pipeline.syncAndReturnAll(); -
事务和管道都是异步的，个人感觉，在管道中再进行事务调用，没有必要，不如直接进行事务模式。
-
分布式中，连接池的性能比直连的性能略好(见后续测试部分)。
-
分布式调用中不支持事务。
因为事务是在服务器端实现，而在分布式中，每批次的调用对象都可能访问不同的机器，所以，没法进行事务。
十、测试
运行上面的代码，进行测试，其结果如下：
|
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
|
分布式中，连接池方式调用不但线程安全外，根据上面的测试数据，也可以看出连接池比直连的效率更好。
十一、完整的测试代码
|
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");
}
} |
From: http://www.open-open.com/lib/view/open1410485827242.html
相关推荐
Jedis是Redis的Java客户端，它提供了一个丰富的API来操作Redis数据存储系统。Redis是一个高性能的键值数据库，常用于缓存、消息中间件以及数据结构服务器等场景。Jedis作为Java开发者与Redis交互的主要工具，使得在...
Redis与Java客户端的交互是通过Java Redis客户端库实现的，如Jedis和Lettuce。Jedis是较早且被广泛使用的Redis客户端，它支持所有Redis命令，适用于简单易用的API接口。Lettuce则是一个更现代的客户端，它提供了基于...
Java基于Redis实现分布式锁代码实例 分布式锁的必要性 在多线程环境中，资源竞争是一个常见的问题。例如，在一个简单的用户操作中，一个线程修改用户状态，首先在内存中读取用户状态，然后在内存中进行修改，然后...
在Java中，我们通常使用Jedis或Lettuce作为Redis的客户端库。这里，我们假设`RedisClientTemplate`是基于Jedis实现的，因为Jedis是更常见的选择，尤其是在早期项目中。当然，如果使用的是Lettuce，其API设计会有所...
Jedis是Redis官方推荐的Java客户端，提供了丰富的API来操作Redis。 1. **引入依赖**：在项目中，需要添加`jedis-2.1.0.jar`作为依赖。对于Maven项目，可以在pom.xml文件中添加如下依赖： ```xml <groupId>redis...
Jedis是Redis的Java客户端，它提供了丰富的API来与Redis服务器进行交互。本文将深入探讨Jedis在Pipeline、分布式ID生成器以及分布式锁（包括watch和multi命令）方面的应用，以帮助理解其在分布式环境中的高效操作。 ...
自旋式加锁是一种常见的分布式锁实现方式。在Java中，我们可以创建一个`LockService`类，其中包含一个循环尝试获取锁的方法。当尝试获取锁失败时（即`SETNX`返回`false`），线程会进入循环等待一段时间后再次尝试，...
通过学习和使用Jedis，开发者能够轻松地将Java应用程序与Redis集成，利用Redis的强大功能进行数据存储、缓存管理和分布式计算。结合Jedis提供的丰富API，开发者可以实现高效、可靠的Redis操作。
Jedis是Java语言中操作Redis的客户端库，它提供了丰富的API来与Redis服务器进行交互，实现了包括字符串、哈希、列表、集合、有序集合等多种数据类型的操作。 在Java项目中集成Redis，首先你需要在项目的类路径下...
总结来说，Java调用Redis涉及到的关键知识点包括：Jedis客户端的使用，连接和验证，基本的键值操作（如set和get），以及在实际项目中如何扩展到其他数据结构和集群环境。通过这个简单的Demo，开发者可以快速了解和...
Jedis是Java语言中广泛使用的Redis客户端库，它提供了丰富的API来操作Redis服务器，包括数据的读写、事务处理、发布订阅等功能。这篇“征服Redis + Jedis”的博文很可能是介绍如何在Java应用中高效地使用Redis和...
Jedis是Java语言中广泛使用的Redis客户端库，提供了丰富的API以便于与Redis服务器进行交互。在本测试环境中，我们将探讨如何利用Jedis进行Redis的基本操作，包括增删等。 首先，我们需要在本地或服务器上安装Redis...
Java客户端库如JedisCluster或Lettuce提供了连接和操作Redis集群的API。 批量插入String类型数据时，通常使用`JedisCluster`类中的`mset`方法。这个方法允许一次性设置多个键值对，但需要注意的是，由于Redis集群的...
标题中的“jedis-2.9.0.jar”是指Jedis的一个特定版本，它是Java语言中用于连接和操作Redis数据库的客户端库。Jedis是开源的，由Pascal Lesier开发，它提供了丰富的API，使得Java开发者能够方便地在应用程序中集成...
Jedis是Java社区广泛使用的Redis客户端，提供了丰富的API接口供开发者调用。在项目中，可以通过Maven或Gradle添加依赖： ```xml <!-- Maven --> <groupId>redis.clients <artifactId>jedis <version>3.7.0 //...
首先，我们需要引入Jedis库，这是一个Java客户端，用于与Redis服务器进行交互。确保在项目中已经添加了Jedis的依赖，如Maven项目可以在pom.xml中添加以下依赖： ```xml <groupId>redis.clients <artifactId>...
【基于Redis实现分布式应用限流的方法】 限流是保护系统免受高并发访问或恶意攻击的重要手段，通过限制系统的处理速度或在特定时间窗口内处理的请求数量，防止系统资源耗尽导致服务崩溃。Redis，作为一款高效且广泛...
**Jedis源码详解——深度探索Redis Java客户端** 在Java开发中，Jedis是与Redis进行交互的常用客户端库，它提供了丰富的API用于操作Redis的数据结构。本文将深入解析Jedis的源码，帮助开发者更好地理解和使用这个...
Java连接Redis是将Java应用程序与Redis内存数据存储系统进行交互的一种技术。Redis是一个高性能的键值数据库，广泛用于缓存、消息队列等场景。在Java中，我们通常使用Jedis库来实现与Redis的连接。Jedis是Redis官方...