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


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

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

@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的命令。

看下面例子:

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

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

@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提供的方法而言,是可以做到在管道中使用事务,其代码如下:

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

但是经测试(见本文后续部分),发现其效率和单独使用事务差不多,甚至还略微差点。 
五、分布式直连同步调用

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

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

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

七、分布式连接池同步调用 (适用于2.2及以下版本)

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

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

上面是同步方式,当然还有异步方式。 
八、分布式连接池异步调用 (适用于2.2及以下版本)

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

九、需要注意的地方

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

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

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

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

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

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

十、测试

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

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片:

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片:

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片:

Simple@Sharing SET: 14.055 seconds 
Pipelined@Sharing SET: 8.185 seconds 
Simple@Pool SET: 13.29 seconds 
Pipelined@Pool SET: 7.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;

@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"); 
    } 
}

 

Java客户端Jedis的八种调用方式的更多相关文章

  1. 【转载】Redis的Java客户端Jedis的八种调用方式(事务、管道、分布式…)介绍

    转载地址:http://blog.csdn.net/truong/article/details/46711045 关键字:Redis的Java客户端Jedis的八种调用方式(事务.管道.分布式…)介 ...

  2. Redis的Java客户端Jedis的八种调用方式(事务、管道、分布式)介绍

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

  3. Jedis的八种调用方式(功能:事务,管道)

        1. packagecom.irwin.redis;     2.       3. importjava.util.Arrays;     4. importjava.util.List; ...

  4. 9、redis之事务2-Jedis的八种调用方式(事务、管道、分布式)介绍

    1.普通同步 @Test public void test1Normal() { Jedis jedis = new Jedis("localhost"); long start ...

  5. 同步(Sync)/异步(Async),阻塞(Block)/非阻塞(Unblock)四种调用方式

    1. 概念理解        在进行网络编程时,我们常常见到同步(Sync)/异步(Async),阻塞(Block)/非阻塞(Unblock)四种调用方式:   同步/异步主要针对C端: 同步:    ...

  6. JMM——Java内存模型抽象|八种同步操作|操作规则

    JMM 调用栈&本地变量在线程栈上 对象整体在堆上(包括其本地变量,不论类型),栈有其引用即可访问, 线程调用同一个对象时,是访问该对象的私有拷贝 每个CPU有自己的高速缓存 高速缓存存在意义 ...

  7. 【转】SVG与HTML、JavaScript的三种调用方式

    原文:https://www.cnblogs.com/guohu/p/5085045.html SVG与HTML.JavaScript的三种调用方式 一.在HTMl中访问SVG的DOM 1 2 3 4 ...

  8. Redis(九):Redis的Java客户端Jedis

    Redis的Java客户端Jedis导航目录: 安装JDK 安装Eclipse Jedis所需要的Jar包 Jedis常用操作 JedisPool 安装JDK tar -zxvf jdk-7u67-l ...

  9. 9.Redis的Java客户端Jedis

    Redis的Java客户端Jedis Jedis所需jar包   commons-pool-1.6.jar jedis-2.1.0.jar 1.Jedis常用操作(jedis中的api 和 我们在 l ...

随机推荐

  1. DB2查询当前时间与指定时间的时间差(相隔的秒数)

    DB2查询当前时间与指定时间的时间差(相隔的秒数). 例子:“拍品表 auct_item”中有个“结束时间 end_date”的字段,求结束时间与当前时间的间隔秒数. select  (DAYS(a. ...

  2. install-file -Dfile=J:\project01\workspace\service\lib\javapns-jdk16-163.jar -DgroupId=org.json -Dar

    今天在开发项目的时候发现了一个问题,所以通过博客来记录起来! 为了以后在问题的解决方面能得到借鉴! 问题的现象是这种: 这样会报错的.pom.xml文件他在编译.检查他的文件语法的时候是须要參考库中的 ...

  3. 并行计算基础&amp;编程模型与工具

    在当前计算机应用中,对快速并行计算的需求是广泛的,归纳起来,主要有三种类型的应用需求: 计算密集(Computer-Intensive)型应用,如大型科学project计算与数值模拟: 数据密集(Da ...

  4. python - 类的方法

    类的方法分为:普通方法. 静态方法和类方法   调用方式 特征 普通方法 由对象去调用执行,属于类 至少一个self,对象调用 静态方法 属于类,但通过类来调用,不依赖于任何对象,方法内部不需要对象封 ...

  5. 黑马程序员——Java高级应用(一)

    ------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS ...

  6. Javscript中的null和undefined

    1.null是JavaScript关键字,含义是“非对象”,它可以表示数字.字符串和对象是“无值”的. var x = null; typeof x ;//返回“object” var x=null, ...

  7. silverlight 生产图表(动态图表类型,Y轴数量) .xaml.cs文件

    silverlight 页面后台方法 .xaml.cs文件 public void CreateChart(Grid oGrid, ObservableCollection<ListItem&g ...

  8. 找不到类型“IBatisService.boxManageService”,它在 ServiceHost 指令中提供为 Service 特性值,或在配置元素 system.serviceModel/serviceHostingEnvironment/serviceActivations 中提供。

    找不到类型“IBatisService.boxManageService”,它在 ServiceHost 指令中提供为 Service 特性值,或在配置元素 system.serviceModel/s ...

  9. 1236 hdu排名

    Problem Description 今天的上机考试虽然有实时的Ranklist,但上面的排名只是根据完成的题数排序,没有考虑 每题的分值,所以并不是最后的排名.给定录取分数线,请你写程序找出最后通 ...

  10. 流输入练习——寻找Sb.VI codevs 3096

    题目描述 Description 已知某开放授权人员名叫Serb,由于经常修改各种数据,因此开发人员们都喊他SB.现在他和许多人一起过飞机安检,排成了一长队列,请问SB.是否在队列中. 输入描述 In ...