前言
Redis是一個著名的key-value存儲系統，也是nosql中的最常見的一種。其實，個人認為，redis最強大的地方不在于其存儲，而在于其強大的緩存作用。
我們可以把它想象成一個巨大的(多借點集群，聚合多借點的內存)的Map，也就是Key-Value。
所以，我們可以把它做成緩存組件。
官方推薦的Java版客戶端是jedis，非常強大和穩定，支持事務、管道及有jedis自身實現。我們對redis數據的操作，都可以通過jedis來完成。
那我們就來看一看，jedis不同的調用方式：
(1)普通同步方式
這是一種最簡單和最基礎的調用方式，對于簡單的數據存取需求，我們可以通過這種方式調用。
|
1
2
3
4
5
6
7
8
9
10
11
|
public void jedisNormal() { 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之后都可以返回結果，標記是否成功。 |
(2)事務方式(Transactions)
所謂事務，即一個連續操作，是否執行是一個事務，要么完成，要么失敗，沒有中間狀態。
而redis的事務很簡單，他主要目的是保障，一個client發起的事務中的命令可以連續的執行，而中間不會插入其他client的命令，也就是事務的連貫性。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public void jedisTrans() { 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()方法來取消事務。 |
(3)管道(Pipelining)
管道是一種兩個進程之間單向通信的機制。
那再redis中，為何要使用管道呢？有時候，我們需要采用異步的方式，一次發送多個指令，并且，不同步等待其返回結果。這樣可以取得非常好的執行效率。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public void jedisPipelined() { 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(); } |
(4)管道中調用事務
對于，事務以及管道，這兩個概念我們都清楚了。
在某種需求下，我們需要異步執行命令，但是，又希望多個命令是有連續的，所以，我們就采用管道加事務的調用方式。jedis是支持在管道中調用事務的。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public void jedisCombPipelineTrans() { 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(); } //效率上可能會有所欠缺 |
(5)分布式直連同步調用
這個是分布式直接連接，并且是同步調用，每步執行都返回執行結果。類似地，還有異步管道調用。
其實就是分片。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public void jedisShardNormal() { 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(); } |
(6)分布式直連異步調用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public void jedisShardpipelined() { 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(); } |
(7)分布式連接池同步調用
如果，你的分布式調用代碼是運行在線程中，那么上面兩個直連調用方式就不合適了，因為直連方式是非線程安全的，這個時候，你就必須選擇連接池調用。
連接池的調用方式，適合大規模的redis集群，并且多客戶端的操作。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public void jedisShardSimplePool() { 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(); } |
(8)分布式連接池異步調用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public void jedisShardPipelinedPool() { 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(); } |
(9)需要注意的地方
事務和管道都是異步模式。在事務和管道中不能同步查詢結果。比如下面兩個調用，都是不允許的：
|
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(); |
事務和管道都是異步的，個人感覺，在管道中再進行事務調用，沒有必要，不如直接進行事務模式。
分布式中，連接池的性能比直連的性能略好(見后續測試部分)。
分布式調用中不支持事務。
因為事務是在服務器端實現，而在分布式中，每批次的調用對象都可能訪問不同的機器，所以，沒法進行事務。
總結
分布式中，連接池方式調用不但線程安全外，根據上面的測試數據，也可以看出連接池比直連的效率更好。
經測試分布式中用到的機器越多，調用會越慢。
好了，以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作能帶來一定的幫助，如果有疑問大家可以留言交流，謝謝大家對服務器之家的支持。
原文鏈接：http://blog.csdn.net/u011130752/article/details/53483388
