【pipeline】【分布式的id生成器】【分布式锁【watch】【multi】】【redis分布式】

转自 http://www.bwkeji.com/a/wangzhanjichu/kaifa/20120712/14824.html

 

一、 Pipeline 
官方的申明是：starts a pipeline，which is a very efficient way to send lots of command and read all the responses when you finish sending them。简单点说pipeline实用于批处理惩罚。当有多量的操纵须要一次性履行的时辰，可以用管道。 
示例： 
Jedis jedis = new Jedis（String， int）; 
Pipeline p = jedis.pipelined（）; 
p.set（key，value）;//每个操纵都发送恳求给redis-server 
p.get（key，value）; 

p.sync（）;//这段代码获取所有的response 
这里我进行了20w次连气儿操纵（10w读，10w写），不消pipeline耗时：187242ms，用pipeline耗时：1188ms，可见应用管道后的机能上了一个台阶。看了代码懂得到，管道经由过程一次性写入恳求，然后一次性读取响应。也就是说jedis是：request response，request response，...；pipeline则是：request request... response response的体式格式。如许无需每次恳求都守候server端的响应。 

二、 跨jvm的id生成器 
谈到这个话题，起首要知道redis-server端是单线程来处理惩罚client端的恳求的。 
如许来实现一个id生成器就很是简单了，只要简单的调用jdeis.incr（key）;就搞定了。 
你或许会问，incr是原子操纵吗，能包管不会呈现并发题目吗，不是说了吗，server端是单线程处理惩罚恳求的。 

三、 【跨jvm的锁实现【watch】【multi】】 
起首说下这个题目的应用处景，有些时辰我们营业逻辑是在不合的jvm过程甚至是不合的物理机上的jvm处理惩罚的。如许如何来实现不合jvm上的同步题目呢，其实我们可以基于redis来实现一个锁。 
具体事务和请参考文章：redis进修笔记之事务 
临时找到三种实现体式格式： 
1. 经由过程jedis.setnx（key，value）实现 
     import java.util.Random; 
import org.apache.commons.pool.impl.GenericObjectPool.Config; 

import redis.clients.jedis.Jedis; 
import redis.clients.jedis.JedisPool; 
import redis.clients.jedis.Transaction; 

/** 
* ＠author Teaey 
*/ 
public class RedisLock { 
    //加锁标记 
    public static final String LOCKED = "TRUE"; 
    public static final long ONE_MILLI_NANOS = 1000000L; 
    //默认超不时候（毫秒） 
    public static final long DEFAULT_TIME_OUT = 3000; 
    public static JedisPool pool; 
    public static final Random r = new Random（）; 
    //锁的超不时候（秒），过期删除 
    public static final int EXPIRE = 5 * 60; 
    static { 
        pool = new JedisPool（new Config（）， "host"， 6379）; 
    } 
    private Jedis jedis; 
    private String key; 
    //锁状况标记 
    private boolean locked = false; 

    public RedisLock（String key） { 
        this.key = key; 
        this.jedis = pool.getResource（）; 
    } 

    public boolean lock（long timeout） { 
        long nano = System.nanoTime（）; 
        timeout *= ONE_MILLI_NANOS; 
        try { 
            while （（System.nanoTime（） - nano） < timeout） { 
                if （jedis.setnx（key， LOCKED） == 1） { 
                    jedis.expire（key， EXPIRE）; 
                    locked = true; 
                    return locked; 
                } 
                // 短少憩眠，nano避免呈现活锁 
                Thread.sleep（3， r.nextInt（500））; 
            } 
        } catch （Exception e） { 
        } 
        return false; 
    } 
    public boolean lock（） { 
        return lock（DEFAULT_TIME_OUT）; 
    } 

    // 无论是否加锁成功，必须调用 
    public void unlock（） { 
        try { 
            if （locked） 
                jedis.del（key）; 
        } finally { 
            pool.returnResource（jedis）; 
        } 
    } 
}2. 经由过程事务（multi）实现 
因为采取第一张办法，第二种跟第三种实现只贴了关键代码，望谅解。^_^ 
     public boolean lock_2（long timeout） {        long nano = System.nanoTime（）; 
        timeout *= ONE_MILLI_NANOS; 
        try { 
            while （（System.nanoTime（） - nano） < timeout） { 
                Transaction t = jedis.multi（）; 
                // 开启事务，当server端收到multi指令 
                // 会将该client的号令放入一个队列，然后依次履行，知道收到exec指令 
                t.getSet（key， LOCKED）; 
                t.expire（key， EXPIRE）; 
                String ret = （String） t.exec（）.get（0）; 
                if （ret == null || ret.equals（"UNLOCK"）） { 
                    return true; 
                } 
                // 短少憩眠，nano避免呈现活锁 
                Thread.sleep（3， r.nextInt（500））; 
            } 
        } catch （Exception e） { 
        } 
        return false; 
    }3. 经由过程事务+实现 
    public boolean lock_3（long timeout） {        long nano = System.nanoTime（）; 
        timeout *= ONE_MILLI_NANOS; 
        try { 
            while （（System.nanoTime（） - nano） < timeout） { 
                jedis.watch（key）; 
                // 开启watch之后，若是key的值被批改，则事务失败，exec办法返回null 
                String value = jedis.get（key）; 
                if （value == null || value.equals（"UNLOCK"）） { 
                    Transaction t = jedis.multi（）; 
                    t.setex（key， EXPIRE， LOCKED）; 
                    if （t.exec（） != null） { 
                        return true; 
                    } 
                } 
                jedis.unwatch（）; 
                // 短少憩眠，nano避免呈现活锁 
                Thread.sleep（3， r.nextInt（500））; 
            } 
        } catch （Exception e） { 
        } 
        return false; 
    }终极采取第一种实现，因为加锁只需发送一个恳求，效力最高。 
四、 【redis分布式】 
    最后一个话题，jedis的分布式。在jedis的源码里发了然两种hash算法（MD5，MURMUR Hash（默认）），也可以本身实现redis.clients.util.Hashing接口扩大。 
    List<JedisShardInfo> hosts = new ArrayList<JedisShardInfo>（）;        //server1 
        JedisShardInfo host1 = new JedisShardInfo（""， 6380， 2000）; 
        //server2 
        JedisShardInfo host2 = new JedisShardInfo（""， 6381， 2000）; 
        hosts.add（host1）; 
        hosts.add（host2）; 
        ShardedJedis jedis = new ShardedJedis（hosts）; 
        jedis.set（"key"， ""）;