Login
home
网站首页 > 文章中心 > 其它

Java调用Redis的八种方式_Java调用redis

作者：小编 更新时间：2023-08-07 10:58:09 浏览量：141人看过

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

第一段：普通同步方式

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

Java调用Redis的八种方式_Java调用redis-图1

@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();


Java调用Redis的八种方式_Java调用redis-图2


System.out.println("Simple SET: " + ((end - start)/1000.0) + " seconds");
jedis.disconnect();
}

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

第二段：事务方式(Transactions)

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

看下面例子：

@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 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)


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


@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 results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");
jedis.disconnect();
}


第四段：管道中调用事务


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


@Test
public void test4combPipelineTrans() {
jedis = new Jedis("localhost"); 
long start = System.currentTimeMillis();
Pipeline pipeline = jedis.pipelined();
for (int i = 0; i < 100000; i++) {
    pipeline.set("" + i, "" + i);
List results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");
jedis.disconnect();
}


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


第五段：分布式直连同步调用


@Test
public void test5shardNormal() {
List 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();
}



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


第六段：分布式直连异步调用


@Test
public void test6shardpipelined() {
List 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 results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");

sharding.disconnect();
}


第七段：分布式连接池同步调用


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


@Test
public void test7shardSimplePool() {
List 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();
System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");

pool.destroy();
}



上面是同步方式,当然还有异步方式.


第八段：分布式连接池异步调用


@Test
public void test8shardPipelinedPool() {
List 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 results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");
pool.destroy();
}


第九段：需要注意的地方


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


 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 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 results = pipeline.syncAndReturnAll();


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


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


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


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


十、测试


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


Simple SET: ⑤227 seconds

Transaction SET: 0.5 seconds
Pipelined SET: 0.353 seconds
Pipelined transaction: 0.509 seconds

Simple@Sharing SET: ⑤289 seconds
Pipelined@Sharing SET: 0.348 seconds

Simple@Pool SET: ⑤039 seconds
Pipelined@Pool SET: 0.401 seconds




Simple@Sharing SET: ⑤494 seconds
Pipelined@Sharing SET: 0.51 seconds
Simple@Pool SET: ⑤223 seconds
Pipelined@Pool SET: 0.518 seconds




下面是10片：


Simple@Sharing SET: ⑤9 seconds
Pipelined@Sharing SET: 0.794 seconds
Simple@Pool SET: ⑤624 seconds
Pipelined@Pool SET: 0.762 seconds




下面是100片：


Simple@Sharing SET: 1④055 seconds
Pipelined@Sharing SET: ⑧185 seconds
Simple@Pool SET: 1③29 seconds
Pipelined@Pool SET: ⑦767 seconds




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


十第一段：完整的测试代码


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;

public static void setUpBeforeClass() throws Exception {
    List 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);
public static void tearDownAfterClass() throws Exception {
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");
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 results = tx.exec();
    long end = System.currentTimeMillis();
    System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");
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 results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");
public void test4combPipelineTrans() {
    long start = System.currentTimeMillis();
    Pipeline pipeline = jedis.pipelined();
    for (int i = 0; i < 100000; i++) {
        pipeline.set("" + i, "" + i);
    List results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");
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");
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 results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");
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();
    System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");
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 results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");
}
}


View Code


以上就是土嘎嘎小编为大家整理的Java调用Redis的八种方式相关主题介绍,如果您觉得小编更新的文章只要能对粉丝们有用,就是我们最大的鼓励和动力,不要忘记讲本站分享给您身边的朋友哦！！



    		
    
		
			
				
				
   
	
    




 
      
版权声明：倡导尊重与保护知识产权。未经许可，任何人不得复制、转载、或以其他方式使用本站《原创》内容，违者将追究其法律责任。本站文章内容，部分图片来源于网络，如有侵权，请联系我们修改或者删除处理。

		

		  
			

				
相关推荐

			

			
		
   
    
  
  

    

      
编辑推荐

      
    

    

      
热门文章

      
    

  




  
 Copyright @ 2012-2025 土嘎嘎 版权所有