Jedis使用管道优化批量输出插入的效率

Jedis连接池：

package com.daxin.jedis_datastructure;

/** 
 * 
 * @author  daxin 
 * 
 * @email leodaxin@163com
 * 
 * @date 2017年9月4日 上午10:29:00
 * 
 */
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class RedisUtils {

    // Redis服务器IP
    private static String ADDR = "node";
    // Redis的端口号
    private static int PORT = 6379;
    // 可用连接实例的最大数目，默认值为8；
    // 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    private static int MAX_ACTIVE = 16;
    // 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static int MAX_IDLE = 6;
    // 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    private static int MAX_WAIT = 10000;

    // 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    private static boolean TEST_ON_BORROW = true;
    private static JedisPool jedisPool = null;
    /**
     * 初始化Redis连接池
     */
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWaitMillis(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            jedisPool = new JedisPool(config, ADDR, PORT);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取Jedis实例
     * 
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

通道技术批量插入数据和普通插入效率对比：

package com.daxin.jedis_datastructure;

import java.util.List;
import java.util.UUID;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.Response;

/**
 * 
 * @author daxin
 * 
 * @email leodaxin@163com
 * 
 * @date 2017年9月13日 下午1:34:44
 * 
 *       2291 129072
 * 
 */
public class JedisPip {

    Jedis jedis = null;

    @Before
    public void before() {
        jedis = RedisUtils.getJedis();
        jedis.flushDB();
    }

    @After
    public void after() {
        jedis.close();
    }

    @Test
    public void pipe_jedis() {
        Pipeline pip = jedis.pipelined();

        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            pip.set(UUID.randomUUID().toString(), UUID.randomUUID().toString());
        }
        pip.sync();// 同步获取所有的回应

        System.out.println(System.currentTimeMillis() - start);
        start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            jedis.set(UUID.randomUUID().toString(), UUID.randomUUID().toString());
        }
        System.out.println(System.currentTimeMillis() - start);
    }

}

输出时间分别是：

2291
129072

可以看到使用通道技术插入有较高的效率。产生差距的原因：

Redis 管道技术

Redis是一种基于客户端-服务端模型以及请求/响应协议的TCP服务。这意味着通常情况下一个请求会遵循以下步骤：

• 客户端向服务端发送一个查询请求，并监听Socket返回，通常是以阻塞模式，等待服务端响应。
• 服务端处理命令，并将结果返回给客户端。

Redis 管道技术可以在服务端未响应时，客户端可以继续向服务端发送请求，并最终一次性读取所有服务端的响应。

管道技术的优势

管道技术最显著的优势是提高了 redis 服务的性能。

使用管道技术获取结果：

@Test
    public void pipe_get() {

        Pipeline pip = jedis.pipelined();
        pip.multi();
        for (int i = 0; i < 100000; i++) {
            pip.set(i + "", UUID.randomUUID().toString());
        }

        Response<List<Object>> r = pip.exec();
        pip.multi();
        for (int i = 0; i < 100000; i++) {
            pip.get("" + i);
        }

        r = pip.exec();
        pip.sync();// 调用syn会关闭管道，所以在调用syn之后就不可以在使用管道了
        System.out.println(r.get().get(0));
        System.out.println(r.get().size());

    }