jedis调用redis之总结

package com.alex.xiyoubang;

import java.util.Arrays;
import java.util.List;

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;


public class JedisCompare {

    private static Jedis jedis;
    private static ShardedJedis sharding;
    private static ShardedJedisPool pool;

    public static void main(String[] args) {
        normal();
        transaction();
        pipelined();
        combPipelineTrans();
        shardNormal();
        shardpipelined();
        shardSimplePool();
        shardPipelinedPool();
    }
    /** * 初始化 */
    public static void initJedis() {
        List<JedisShardInfo> shards = Arrays.asList(
                new JedisShardInfo("192.168.1.171",6379),
                new JedisShardInfo("192.168.1.171",6379)); //使用相同的ip:port,仅作测试


        jedis = new Jedis("192.168.1.171"); 
        sharding = new ShardedJedis(shards);

        pool = new ShardedJedisPool(new JedisPoolConfig(), shards);
    }
    /** * 销毁 */
    public static void destroyJedis() {
        jedis.disconnect();
        sharding.disconnect();
        pool.destroy();
    }

    /** * 最简单和基础的调用方式 */
    public static void normal() {
        initJedis();
        System.out.println(jedis.flushDB());
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            String result = jedis.set("normal" + i, "normal" + i);
        }
        long end = System.currentTimeMillis();
        System.out.println("normal waste: " + ((end - start)/1000.0) + " seconds");
        destroyJedis();
    }

   /** * 事务方式 */
    public static void transaction() {
        initJedis();
        long start = System.currentTimeMillis();
        Transaction tx = jedis.multi();
        for (int i = 0; i < 1000; i++) {
            tx.set("transaction" + i, "transaction" + i);
        }
        List<Object> results = tx.exec();
        long end = System.currentTimeMillis();
        System.out.println("transaction waste: " + ((end - start)/1000.0) + " seconds");
        destroyJedis();
    }

   /** * 管道 */
    public static void pipelined() {
        initJedis();
        Pipeline pipeline = jedis.pipelined();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            pipeline.set("pipelined" + i, "pipelined" + i);
        }
        List<Object> results = pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        System.out.println("pipelined waste: " + ((end - start)/1000.0) + " seconds");
        destroyJedis();
    }

   /** * 管道中调用事务 */
    public static void combPipelineTrans() {
        initJedis();
        long start = System.currentTimeMillis();
        Pipeline pipeline = jedis.pipelined();
        pipeline.multi();
        for (int i = 0; i < 1000; i++) {
            pipeline.set("combPipelineTrans" + i, "combPipelineTrans" + i);
        }
        pipeline.exec();
        List<Object> results = pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        System.out.println("combPipelineTrans waste: " + ((end - start)/1000.0) + " seconds");
        destroyJedis();
    }

   /** * 分布式直连同步调用 */
    public static void shardNormal() {
        initJedis();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            String result = sharding.set("shardNormal" + i, "shardNormal" + i);
        }
        long end = System.currentTimeMillis();
        System.out.println("shardNormal waste: " + ((end - start)/1000.0) + " seconds");
        destroyJedis();
    }

   /** * 分布式直连异步调用 */
    public static void shardpipelined() {
        initJedis();
        ShardedJedisPipeline pipeline = sharding.pipelined();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            pipeline.set("shardpipelined" + i, "shardpipelined" + i);
        }
        List<Object> results = pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        System.out.println("shardpipelined waste: " + ((end - start)/1000.0) + " seconds");
        destroyJedis();
    }

   /** * 分布式连接池同步调用 */
    public static void shardSimplePool() {
        initJedis();
        ShardedJedis one = pool.getResource();

        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            String result = one.set("shardSimplePool" + i, "shardSimplePool" + i);
        }
        long end = System.currentTimeMillis();
        pool.returnResource(one);
        System.out.println("shardSimplePool waste: " + ((end - start)/1000.0) + " seconds");
        destroyJedis();
    }

   /** * 分布式连接池异步调用 */
    public static void shardPipelinedPool() {
        initJedis();
        ShardedJedis one = pool.getResource();

        ShardedJedisPipeline pipeline = one.pipelined();

        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            pipeline.set("shardPipelinedPool" + i, "shardPipelinedPool" + i);
        }
        List<Object> results = pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        pool.returnResource(one);
        System.out.println("shardPipelinedPool waste: " + ((end - start)/1000.0) + " seconds");
        destroyJedis();
    }
}

结果：

1、事务和管道都是异步模式。在事务和管道中不能同步查询结果。
2、事务和管道都是异步的，在管道中再进行事务调用，没有必要，不如直接进行事务模式。
3、分布式中，连接池的性能比直连的性能略好。
4、分布式调用中不支持事务。
因为事务是在服务器端实现，而在分布式中，每批次的调用对象都可能访问不同的机器，所以，没法进行事务。
5、分布式中，连接池方式调用不但线程安全外，根据上面的测试数据，也可以看出连接池比直连的效率更好。