Redis分佈式鎖實現秒殺業務(樂觀鎖、悲觀鎖)

1、業務場景

　　所謂秒殺，從業務角度看，是短期內多個用戶「爭搶」資源，這裏的資源在大部分秒殺場景裏是商品；將業務抽象，技術角度看，秒殺就是多個線程對資源進行操做，因此實現秒殺，就必須控制線程對資源的爭搶，既要保證高效併發，也要保證操做的正確。

2、一些可能的實現

　　剛纔提到過，實現秒殺的關鍵點是控制線程對資源的爭搶，根據基本的線程知識，能夠不加思索的想到下面的一些方法：

1)、秒殺在技術層面的抽象應該就是一個方法，在這個方法裏可能的操做是將商品庫存-1，將商品加入用戶的購物車等等，在不考慮緩存的狀況下應該是要操做數據庫的。那麼最簡單直接的實現就是在這個方法上加上synchronized關鍵字，通俗的講就是鎖住整個方法；

2)、鎖住整個方法這個策略簡單方便，可是彷佛有點粗暴。能夠稍微優化一下，只鎖住秒殺的代碼塊，好比寫數據庫的部分；

3)、既然有併發問題，那我就讓他「不併發」，將全部的線程用一個隊列管理起來，使之變成串行操做，天然不會有併發問題。

　　上面所述的方法都是有效的，可是都很差。爲何？第一和第二種方法本質上是「加鎖」，可是鎖粒度依然比較高。什麼意思？試想一下，若是兩個線程同時執行秒殺方法，這兩個線程操做的是不一樣的商品,從業務上講應該是能夠同時進行的，可是若是採用第一二種方法，這兩個線程也會去爭搶同一個鎖，這實際上是沒必要要的。第三種方法也沒有解決上面說的問題。

　　那麼如何將鎖控制在更細的粒度上呢？能夠考慮爲每一個商品設置一個互斥鎖，以和商品ID相關的字符串爲惟一標識，這樣就能夠作到只有爭搶同一件商品的線程互斥，不會致使全部的線程互斥。分佈式鎖剛好能夠幫助咱們解決這個問題。

3、具體的實現

須要考慮的問題

一、用什麼操做redis？幸好redis已經提供了jedis客戶端用於java應用程序，直接調用jedis API便可。

二、怎麼實現加鎖？「鎖」實際上是一個抽象的概念，將這個抽象概念變爲具體的東西，就是一個存儲在redis裏的key-value對，key是於商品ID相關的字符串來惟一標識，value其實並不重要，由於只要這個惟一的key-value存在，就表示這個商品已經上鎖。

三、如何釋放鎖？既然key-value對存在就表示上鎖，那麼釋放鎖就天然是在redis裏刪除key-value對。

四、阻塞仍是非阻塞？筆者採用了阻塞式的實現，若線程發現已經上鎖，會在特定時間內輪詢鎖。

五、如何處理異常狀況？好比一個線程把一個商品上了鎖，可是因爲各類緣由，沒有完成操做（在上面的業務場景裏就是沒有將庫存-1寫入數據庫），天然沒有釋放鎖，這個狀況筆者加入了鎖超時機制，利用redis的expire命令爲key設置超時時長，過了超時時間redis就會將這個key自動刪除，即強制釋放鎖（能夠認爲超時釋放鎖是一個異步操做，由redis完成，應用程序只須要根據系統特色設置超時時間便可）。

4、樂觀鎖實現秒殺系統

　　咱們知道大多數是基於數據版本（version）的記錄機制實現的。即爲數據增長一個版本標識，在基於數據庫表的版本解決方案中，通常是經過爲數據庫表增長一個」version」字段來實現讀取出數據時，將此版本號一同讀出，以後更新時，對此版本號加1。此時，將提交數據的版本號與數據庫表對應記錄的當前版本號進行比對，若是提交的數據版本號大於數據庫當前版本號，則予以更新，不然認爲是過時數據。redis中可使用watch命令會監視給定的key，當exec時候若是監視的key從調用watch後發生過變化，則整個事務會失敗。也能夠調用watch屢次監視多個key。這樣就能夠對指定的key加樂觀鎖了。注意watch的key是對整個鏈接有效的，事務也同樣。若是鏈接斷開，監視和事務都會被自動清除。固然了exec，discard，unwatch命令都會清除鏈接中的全部監視。

　　Redis中的事務(transaction)是一組命令的集合。事務同命令同樣都是Redis最小的執行單位，一個事務中的命令要麼都執行，要麼都不執行。Redis事務的實現須要用到 MULTI 和 EXEC 兩個命令，事務開始的時候先向Redis服務器發送 MULTI 命令，而後依次發送須要在本次事務中處理的命令，最後再發送 EXEC 命令表示事務命令結束。Redis的事務是下面4個命令來實現 ：

1).multi，開啓Redis的事務，置客戶端爲事務態。

2).exec，提交事務，執行從multi到此命令前的命令隊列，置客戶端爲非事務態。

3).discard，取消事務，置客戶端爲非事務態。

4).watch,監視鍵值對，做用時若是事務提交exec時發現監視的監視對發生變化，事務將被取消。

實現代碼以下：

import java.util.List;
import java.util.Set;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.transaction.Transaction;
import redis.clients.jedis.Jedis;

/**
 * 樂觀鎖實現秒殺系統
 *
 */
public class OptimisticLockTest {

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        initProduct();
        initClient();
        printResult();
        long endTime = System.currentTimeMillis();
        long time = endTime - startTime;
        System.out.println("程序運行時間 ： " + (int)time + "ms");
    }

    /**
     * 初始化商品
     * @date 2017-10-17
     */
    public static void initProduct() {
        int prdNum = 100;//商品個數
        String key = "prdNum";
        String clientList = "clientList";//搶購到商品的顧客列表
        Jedis jedis = RedisUtil.getInstance().getJedis();
        if (jedis.exists(key)) {
            jedis.del(key);
        }
        if (jedis.exists(clientList)) {
            jedis.del(clientList);
        }
        jedis.set(key, String.valueOf(prdNum));//初始化商品
        RedisUtil.returnResource(jedis);
    }

    /**
     * 顧客搶購商品（秒殺操做）
     * @date 2017-10-17
     */
    public static void initClient() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        int clientNum = 10000;//模擬顧客數目
        for (int i = 0; i < clientNum; i++) {
            cachedThreadPool.execute(new ClientThread(i));//啓動與顧客數目相等的消費者線程
        }
        cachedThreadPool.shutdown();//關閉線程池
        while (true) {
            if (cachedThreadPool.isTerminated()) {
                System.out.println("全部的消費者線程均結束了");    
                break;   
            }
            try {
                Thread.sleep(100);
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    }

    /**
     * 打印搶購結果
     * @date 2017-10-17
     */
    public static void printResult() {
        Jedis jedis = RedisUtil.getInstance().getJedis();
        Set<String> set = jedis.smembers("clientList");
        int i = 1;
        for (String value : set) {
            System.out.println("第" + i++ + "個搶到商品，"+value + " "); 
        }
        RedisUtil.returnResource(jedis);
    }


    /**
     * 內部類：模擬消費者線程
     */
    static class ClientThread implements Runnable{

        Jedis jedis = null;
        String key = "prdNum";//商品主鍵
        String clientList = "clientList";//搶購到商品的顧客列表主鍵
        String clientName;

        public ClientThread(int num){
            clientName = "編號=" + num;
        }

//      1.multi，開啓Redis的事務，置客戶端爲事務態。 
//      2.exec，提交事務，執行從multi到此命令前的命令隊列，置客戶端爲非事務態。 
//      3.discard，取消事務，置客戶端爲非事務態。 
//      4.watch,監視鍵值對，做用是若是事務提交exec時發現監視的鍵值對發生變化，事務將被取消。 
        @Override
        public void run() {
            try {
                Thread.sleep((int)Math.random()*5000);//隨機睡眠一下
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            while(true){
                System.out.println("顧客：" + clientName + "開始搶購商品");
                jedis = RedisUtil.getInstance().getJedis();
                try {
                    jedis.watch(key);//監視商品鍵值對，做用時若是事務提交exec時發現監視的鍵值對發生變化，事務將被取消
                    int prdNum = Integer.parseInt(jedis.get(key));//當前商品個數
                    if (prdNum > 0) {
                        Transaction transaction = (Transaction) jedis.multi();//開啓redis事務
                        ((Jedis) transaction).set(key,String.valueOf(prdNum - 1));//商品數量減一
                        List<Object> result = ((redis.clients.jedis.Transaction) transaction).exec();//提交事務(樂觀鎖：提交事務的時候纔會去檢查key有沒有被修改)
                        if (result == null || result.isEmpty()) {
                            System.out.println("很抱歉，顧客:" + clientName + "沒有搶到商品");// 多是watch-key被外部修改，或者是數據操做被駁回
                        }else {
                            jedis.sadd(clientList, clientName);//搶到商品的話記錄一下
                            System.out.println("恭喜，顧客:" + clientName + "搶到商品");  
                            break; 
                        }
                    }else {
                         System.out.println("很抱歉，庫存爲0，顧客:" + clientName + "沒有搶到商品");  
                         break; 
                    }
                } catch (Exception e) {
                    // TODO: handle exception
                }finally{
                    jedis.unwatch();
                    RedisUtil.returnResource(jedis);
                }
            }
        }
    }
}

5、悲觀鎖實現秒殺系統

　　實現秒殺的類PessimisticLockTest：

import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import redis.clients.jedis.Jedis;
import test.OptimisticLockTest.ClientThread;

public class PessimisticLockTest {

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        initProduct();
        initClient();
        printResult();
        long endTime = System.currentTimeMillis();
        long time = endTime - startTime;
        System.out.println("程序運行時間 ： " + (int)time + "ms");
    }

    /**
     * 初始化商品
     * @date 2017-10-17
     */
    public static void initProduct() {
        int prdNum = 100;//商品個數
        String key = "prdNum";
        String clientList = "clientList";//搶購到商品的顧客列表
        Jedis jedis = RedisUtil.getInstance().getJedis();
        if (jedis.exists(key)) {
            jedis.del(key);
        }
        if (jedis.exists(clientList)) {
            jedis.del(clientList);
        }
        jedis.set(key, String.valueOf(prdNum));//初始化商品
        RedisUtil.returnResource(jedis);
    }

    /**
     * 顧客搶購商品（秒殺操做）
     * @date 2017-10-17
     */
    public static void initClient() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        int clientNum = 10000;//模擬顧客數目
        for (int i = 0; i < clientNum; i++) {
            cachedThreadPool.execute(new ClientThread(i));//啓動與顧客數目相等的消費者線程
        }
        cachedThreadPool.shutdown();//關閉線程池
        while (true) {
            if (cachedThreadPool.isTerminated()) {
                System.out.println("全部的消費者線程均結束了");    
                break;   
            }
            try {
                Thread.sleep(100);
            } catch (Exception e) {
                // TODO: handle exception
            }
        }
    }

    /**
     * 打印搶購結果
     * @date 2017-10-17
     */
    public static void printResult() {
        Jedis jedis = RedisUtil.getInstance().getJedis();
        Set<String> set = jedis.smembers("clientList");
        int i = 1;
        for (String value : set) {
            System.out.println("第" + i++ + "個搶到商品，"+value + " "); 
        }
        RedisUtil.returnResource(jedis);
    }

    /**
     * 消費者線程
     */
    static class PessClientThread implements Runnable{

        String key = "prdNum";//商品主鍵
        String clientList = "clientList";//搶購到商品的顧客列表
        String clientName;
        Jedis jedis = null;
        RedisBasedDistributedLock redisBasedDistributedLock; 

        public PessClientThread(int num){
            clientName = "編號=" + num;
            init();
        }

        public void init() {
            jedis = RedisUtil.getInstance().getJedis();
            redisBasedDistributedLock = new RedisBasedDistributedLock(jedis, "lock.lock", 5 * 1000); 
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            while (true) {
                if (Integer.parseInt(jedis.get(key)) <= 0) {
                    break;//緩存中沒有商品，跳出循環，消費者線程執行完畢
                }
                //緩存中還有商品，取鎖，商品數目減一
                 System.out.println("顧客:" + clientName + "開始搶商品");  
                 if (redisBasedDistributedLock.tryLock(3,TimeUnit.SECONDS)) {//等待3秒獲取鎖，不然返回false(悲觀鎖：每次拿數據都上鎖)
                    int prdNum = Integer.parseInt(jedis.get(key));//再次取得商品緩存數目
                    if (prdNum > 0) {
                        jedis.decr(key);//商品數減一
                        jedis.sadd(clientList, clientName);//將搶購到商品的顧客記錄一下
                        System.out.println("恭喜，顧客:" + clientName + "搶到商品");  
                    } else {  
                        System.out.println("抱歉，庫存爲0，顧客:" + clientName + "沒有搶到商品");  
                    }
                    redisBasedDistributedLock.unlock0();//操做完成釋放鎖
                    break;
                }
            }
            //釋放資源
            redisBasedDistributedLock = null;
            RedisUtil.returnResource(jedis);
        }
    }
}

抽象鎖實現AbstractLock ：

import java.util.concurrent.TimeUnit;  
import java.util.concurrent.locks.Lock;  

/** 
 * 鎖的骨架實現, 真正的獲取鎖的步驟由子類去實現. 
 *  
 */  
public abstract class AbstractLock implements Lock {  

    /** 
     * <pre> 
     * 這裏需不須要保證可見性值得討論, 由於是分佈式的鎖,  
     * 1.同一個jvm的多個線程使用不一樣的鎖對象其實也是能夠的, 這種狀況下不須要保證可見性  
     * 2.同一個jvm的多個線程使用同一個鎖對象, 那可見性就必需要保證了. 
     * </pre> 
     */  
    protected volatile boolean locked;  

    /** 
     * 當前jvm內持有該鎖的線程(if have one) 
     */  
    private Thread exclusiveOwnerThread;  

    public void lock() {  
        try {  
            lock(false, 0, null, false);  
        } catch (InterruptedException e) {  
            // TODO ignore  
        }  
    }  

    public void lockInterruptibly() throws InterruptedException {  
        lock(false, 0, null, true);  
    }  

    public boolean tryLock(long time, TimeUnit unit) {  
        try {  
            System.out.println("ghggggggggggggg");  
            return lock(true, time, unit, false);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
            System.out.println("" + e);  
        }  
        return false;  
    }  

    public boolean tryLockInterruptibly(long time, TimeUnit unit) throws InterruptedException {  
        return lock(true, time, unit, true);  
    }  

    public void unlock() {  
        // TODO 檢查當前線程是否持有鎖  
        if (Thread.currentThread() != getExclusiveOwnerThread()) {  
            throw new IllegalMonitorStateException("current thread does not hold the lock");  
        }  

        unlock0();  
        setExclusiveOwnerThread(null);  
    }  

    protected void setExclusiveOwnerThread(Thread thread) {  
        exclusiveOwnerThread = thread;  
    }  

    protected final Thread getExclusiveOwnerThread() {  
        return exclusiveOwnerThread;  
    }  

    protected abstract void unlock0();  

    /** 
     * 阻塞式獲取鎖的實現 
     *  
     * @param useTimeout 是否超時
     * @param time 獲取鎖的等待時間
     * @param unit 時間單位
     * @param interrupt 
     *            是否響應中斷 
     * @return 
     * @throws InterruptedException 
     */  
    protected abstract boolean lock(boolean useTimeout, long time, TimeUnit unit, boolean interrupt)  
            throws InterruptedException;  
} 

基於Redis的SETNX操做實現的分佈式鎖RedisBasedDistributedLock：

 

package test;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import redis.clients.jedis.Jedis;

/** 
 * 基於Redis的SETNX操做實現的分佈式鎖 
 *  
 * 獲取鎖時最好用lock(long time, TimeUnit unit), 以避免網路問題而致使線程一直阻塞 
 */  
public class RedisBasedDistributedLock extends AbstractLock{

    private Jedis jedis;
    protected String lockKey;//鎖的名字
    protected long lockExpire;//鎖的有效時長(毫秒)

    public RedisBasedDistributedLock(Jedis jedis,String lockKey,long lockExpire){
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.lockExpire = lockExpire;
    }

    @Override
    public boolean tryLock() {
        long lockExpireTime = System.currentTimeMillis() + lockExpire + 1;//鎖超時時間
        String stringOfLockExpireTime = String.valueOf(lockExpireTime);
        if (jedis.setnx(lockKey, stringOfLockExpireTime) == 1) {//獲取到鎖
            //設置相關標識
            locked = true;
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        String value = jedis.get(lockKey);
        if (value != null && isTimeExpired(value)) {//鎖是過時的
            //假設多個線程(非單jvm)同時走到這裏
            String oldValue = jedis.getSet(lockKey, stringOfLockExpireTime);//原子操做  
            // 可是走到這裏時每一個線程拿到的oldValue確定不可能同樣(由於getset是原子性的)  
            // 假如拿到的oldValue依然是expired的，那麼就說明拿到鎖了 
            if (oldValue != null && isTimeExpired(oldValue)) {//拿到鎖
                //設置相關標識
                locked = true;
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
        }
        return false;
    }

    @Override
    public Condition newCondition() {
        // TODO Auto-generated method stub
        return null;
    }

    /**
     * 鎖未過時，釋放鎖
     */
    @Override
    protected void unlock0() {
        // 判斷鎖是否過時  
        String value = jedis.get(lockKey);  
        if (!isTimeExpired(value)) {  
            doUnlock();  
        } 
    }

    /**
     * 釋放鎖
     * @date 2017-10-18
     */
    public void doUnlock() {
        jedis.del(lockKey);
    }

    /**
     * 查詢當前的鎖是否被別的線程佔有
     * @return 被佔有true，未被佔有false
     * @date 2017-10-18
     */
    public boolean isLocked(){
        if (locked) {
            return true;
        }else {
            String value = jedis.get(lockKey);
            // TODO 這裏實際上是有問題的, 想:當get方法返回value後, 假設這個value已是過時的了,  
            // 而就在這瞬間, 另外一個節點set了value, 這時鎖是被別的線程(節點持有), 而接下來的判斷  
            // 是檢測不出這種狀況的.不過這個問題應該不會致使其它的問題出現, 由於這個方法的目的原本就  
            // 不是同步控制, 它只是一種鎖狀態的報告.  
            return !isTimeExpired(value);
        }
    }

    /**
     * 檢測時間是否過時
     * @param value
     * @return
     * @date 2017-10-18
     */
    public boolean isTimeExpired(String value) {
        return Long.parseLong(value) < System.currentTimeMillis();  
    }

    /**
     * 阻塞式獲取鎖的實現
     * @param useTimeout 是否超時
     * @param time 獲取鎖的等待時間
     * @param unit 時間單位
     * @param interrupt 
     *            是否響應中斷 
     */
    @Override
    protected boolean lock(boolean useTimeout, long time, TimeUnit unit,boolean interrupt) throws InterruptedException {
        if (interrupt) {
            checkInterruption();
        }
        long start = System.currentTimeMillis();
        long timeout = unit.toMillis(time);//
        while (useTimeout ? isTimeout(start, timeout) : true) {
            if (interrupt) {
                checkInterruption();
            }
            long lockExpireTime = System.currentTimeMillis() + lockExpire + 1;//鎖的超時時間
            String stringLockExpireTime = String.valueOf(lockExpireTime);
            if (jedis.setnx(lockKey, stringLockExpireTime) == 1) {//獲取到鎖
                //成功獲取到鎖，設置相關標識
                locked = true;
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
        }
        return false;
    }

    /*
     * 判斷是否超時(開始時間+鎖等待超時時間是否大於系統當前時間)
     */
    public boolean isTimeout(long start, long timeout) {
        return start + timeout > System.currentTimeMillis();
    }

    /*
     * 檢查當前線程是否阻塞 
     */
    public void checkInterruption() throws InterruptedException {
        if (Thread.currentThread().isInterrupted()) {
            throw new InterruptedException();
        }
    }
}

 

redis操做工具類RedisUtil：

 

package test;

import java.util.List;  
import java.util.Map;  
import java.util.Set;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import redis.clients.jedis.BinaryClient.LIST_POSITION;  
import redis.clients.jedis.Jedis;  
import redis.clients.jedis.JedisPool;  
import redis.clients.jedis.JedisPoolConfig;  

public class RedisUtil {  

    private static final Logger LOGGER = LoggerFactory.getLogger(RedisUtil.class);  

    private static JedisPool pool = null;  

    private static RedisUtil ru = new RedisUtil();  

    public static void main(String[] args) {  
        RedisUtil redisUtil = RedisUtil.getInstance();  
        redisUtil.set("test", "test");  
        LOGGER.info(redisUtil.get("test"));  
    }  

    private RedisUtil() {  
        if (pool == null) {  
            String ip = "10.62.245.11";  
            int port = 6379;  
            JedisPoolConfig config = new JedisPoolConfig();  
            // 控制一個pool可分配多少個jedis實例，經過pool.getResource()來獲取；  
            // 若是賦值爲-1，則表示不限制；若是pool已經分配了maxActive個jedis實例，則此時pool的狀態爲exhausted(耗盡)。  
            config.setMaxTotal(10000);  
            // 控制一個pool最多有多少個狀態爲idle(空閒的)的jedis實例。  
            config.setMaxIdle(2000);  
            // 表示當borrow(引入)一個jedis實例時，最大的等待時間，若是超過等待時間，則直接拋出JedisConnectionException；  
            config.setMaxWaitMillis(1000 * 100);  
            config.setTestOnBorrow(true);  
            pool = new JedisPool(config, ip, port, 100000);  
        }  

    }  

    public Jedis getJedis() {  
        Jedis jedis = pool.getResource();  
        return jedis;  
    }  

    public static RedisUtil getInstance() {  
        return ru;  
    }  

    /** 
     * <p> 
     * 經過key獲取儲存在redis中的value 
     * </p> 
     * <p> 
     * 並釋放鏈接 
     * </p> 
     *  
     * @param key 
     * @return 成功返回value 失敗返回null 
     */  
    public String get(String key) {  
        Jedis jedis = null;  
        String value = null;  
        try {  
            jedis = pool.getResource();  
            value = jedis.get(key);  
        } catch (Exception e) {  
            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return value;  
    }  

    /** 
     * <p> 
     * 向redis存入key和value,並釋放鏈接資源 
     * </p> 
     * <p> 
     * 若是key已經存在 則覆蓋 
     * </p> 
     *  
     * @param key 
     * @param value 
     * @return 成功 返回OK 失敗返回 0 
     */  
    public String set(String key, String value) {  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.set(key, value);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
            return "0";  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  

    /** 
     * <p> 
     * 刪除指定的key,也能夠傳入一個包含key的數組 
     * </p> 
     *  
     * @param keys 
     *            一個key 也可使 string 數組 
     * @return 返回刪除成功的個數 
     */  
    public Long del(String... keys) {  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.del(keys);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
            return 0L;  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  

    /** 
     * <p> 
     * 經過key向指定的value值追加值 
     * </p> 
     *  
     * @param key 
     * @param str 
     * @return 成功返回 添加後value的長度 失敗 返回 添加的 value 的長度 異常返回0L 
     */  
    public Long append(String key, String str) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.append(key, str);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
            return 0L;  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 判斷key是否存在 
     * </p> 
     *  
     * @param key 
     * @return true OR false 
     */  
    public Boolean exists(String key) {  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.exists(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
            return false;  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  

    /** 
     * <p> 
     * 設置key value,若是key已經存在則返回0,nx==> not exist 
     * </p> 
     *  
     * @param key 
     * @param value 
     * @return 成功返回1 若是存在 和 發生異常 返回 0 
     */  
    public Long setnx(String key, String value) {  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.setnx(key, value);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
            return 0L;  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  

    /** 
     * <p> 
     * 設置key value並制定這個鍵值的有效期 
     * </p> 
     *  
     * @param key 
     * @param value 
     * @param seconds 
     *            單位:秒 
     * @return 成功返回OK 失敗和異常返回null 
     */  
    public String setex(String key, String value, int seconds) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.setex(key, seconds, value);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key 和offset 從指定的位置開始將原先value替換 
     * </p> 
     * <p> 
     * 下標從0開始,offset表示從offset下標開始替換 
     * </p> 
     * <p> 
     * 若是替換的字符串長度太小則會這樣 
     * </p> 
     * <p> 
     * example: 
     * </p> 
     * <p> 
     * value : bigsea@zto.cn 
     * </p> 
     * <p> 
     * str : abc 
     * </p> 
     * <P> 
     * 從下標7開始替換 則結果爲 
     * </p> 
     * <p> 
     * RES : bigsea.abc.cn 
     * </p> 
     *  
     * @param key 
     * @param str 
     * @param offset 
     *            下標位置 
     * @return 返回替換後 value 的長度 
     */  
    public Long setrange(String key, String str, int offset) {  
        Jedis jedis = null;  
        try {  
            jedis = pool.getResource();  
            return jedis.setrange(key, offset, str);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
            return 0L;  
        } finally {  
            returnResource(pool, jedis);  
        }  
    }  

    /** 
     * <p> 
     * 經過批量的key獲取批量的value 
     * </p> 
     *  
     * @param keys 
     *            string數組 也能夠是一個key 
     * @return 成功返回value的集合, 失敗返回null的集合 ,異常返回空 
     */  
    public List<String> mget(String... keys) {  
        Jedis jedis = null;  
        List<String> values = null;  
        try {  
            jedis = pool.getResource();  
            values = jedis.mget(keys);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return values;  
    }  

    /** 
     * <p> 
     * 批量的設置key:value,能夠一個 
     * </p> 
     * <p> 
     * example: 
     * </p> 
     * <p> 
     * obj.mset(new String[]{"key2","value1","key2","value2"}) 
     * </p> 
     *  
     * @param keysvalues 
     * @return 成功返回OK 失敗 異常 返回 null 
     * 
     */  
    public String mset(String... keysvalues) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.mset(keysvalues);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 批量的設置key:value,能夠一個,若是key已經存在則會失敗,操做會回滾 
     * </p> 
     * <p> 
     * example: 
     * </p> 
     * <p> 
     * obj.msetnx(new String[]{"key2","value1","key2","value2"}) 
     * </p> 
     *  
     * @param keysvalues 
     * @return 成功返回1 失敗返回0 
     */  
    public Long msetnx(String... keysvalues) {  
        Jedis jedis = null;  
        Long res = 0L;  
        try {  
            jedis = pool.getResource();  
            res = jedis.msetnx(keysvalues);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 設置key的值,並返回一箇舊值 
     * </p> 
     *  
     * @param key 
     * @param value 
     * @return 舊值 若是key不存在 則返回null 
     */  
    public String getset(String key, String value) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.getSet(key, value);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過下標 和key 獲取指定下標位置的 value 
     * </p> 
     *  
     * @param key 
     * @param startOffset 
     *            開始位置 從0 開始 負數表示從右邊開始截取 
     * @param endOffset 
     * @return 若是沒有返回null 
     */  
    public String getrange(String key, int startOffset, int endOffset) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.getrange(key, startOffset, endOffset);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key 對value進行加值+1操做,當value不是int類型時會返回錯誤,當key不存在是則value爲1 
     * </p> 
     *  
     * @param key 
     * @return 加值後的結果 
     */  
    public Long incr(String key) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.incr(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key給指定的value加值,若是key不存在,則這是value爲該值 
     * </p> 
     *  
     * @param key 
     * @param integer 
     * @return 
     */  
    public Long incrBy(String key, Long integer) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.incrBy(key, integer);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 對key的值作減減操做,若是key不存在,則設置key爲-1 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    public Long decr(String key) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.decr(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 減去指定的值 
     * </p> 
     *  
     * @param key 
     * @param integer 
     * @return 
     */  
    public Long decrBy(String key, Long integer) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.decrBy(key, integer);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key獲取value值的長度 
     * </p> 
     *  
     * @param key 
     * @return 失敗返回null 
     */  
    public Long serlen(String key) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.strlen(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key給field設置指定的值,若是key不存在,則先建立 
     * </p> 
     *  
     * @param key 
     * @param field 
     *            字段 
     * @param value 
     * @return 若是存在返回0 異常返回null 
     */  
    public Long hset(String key, String field, String value) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hset(key, field, value);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key給field設置指定的值,若是key不存在則先建立,若是field已經存在,返回0 
     * </p> 
     *  
     * @param key 
     * @param field 
     * @param value 
     * @return 
     */  
    public Long hsetnx(String key, String field, String value) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hsetnx(key, field, value);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key同時設置 hash的多個field 
     * </p> 
     *  
     * @param key 
     * @param hash 
     * @return 返回OK 異常返回null 
     */  
    public String hmset(String key, Map<String, String> hash) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hmset(key, hash);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key 和 field 獲取指定的 value 
     * </p> 
     *  
     * @param key 
     * @param field 
     * @return 沒有返回null 
     */  
    public String hget(String key, String field) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hget(key, field);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key 和 fields 獲取指定的value 若是沒有對應的value則返回null 
     * </p> 
     *  
     * @param key 
     * @param fields 
     *            可使 一個String 也能夠是 String數組 
     * @return 
     */  
    public List<String> hmget(String key, String... fields) {  
        Jedis jedis = null;  
        List<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hmget(key, fields);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key給指定的field的value加上給定的值 
     * </p> 
     *  
     * @param key 
     * @param field 
     * @param value 
     * @return 
     */  
    public Long hincrby(String key, String field, Long value) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hincrBy(key, field, value);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key和field判斷是否有指定的value存在 
     * </p> 
     *  
     * @param key 
     * @param field 
     * @return 
     */  
    public Boolean hexists(String key, String field) {  
        Jedis jedis = null;  
        Boolean res = false;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hexists(key, field);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key返回field的數量 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    public Long hlen(String key) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hlen(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  

    }  

    /** 
     * <p> 
     * 經過key 刪除指定的 field 
     * </p> 
     *  
     * @param key 
     * @param fields 
     *            能夠是 一個 field 也能夠是 一個數組 
     * @return 
     */  
    public Long hdel(String key, String... fields) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hdel(key, fields);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key返回全部的field 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    public Set<String> hkeys(String key) {  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hkeys(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key返回全部和key有關的value 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    public List<String> hvals(String key) {  
        Jedis jedis = null;  
        List<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hvals(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key獲取全部的field和value 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    public Map<String, String> hgetall(String key) {  
        Jedis jedis = null;  
        Map<String, String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.hgetAll(key);  
        } catch (Exception e) {  
            // TODO  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key向list頭部添加字符串 
     * </p> 
     *  
     * @param key 
     * @param strs 
     *            可使一個string 也可使string數組 
     * @return 返回list的value個數 
     */  
    public Long lpush(String key, String... strs) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lpush(key, strs);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key向list尾部添加字符串 
     * </p> 
     *  
     * @param key 
     * @param strs 
     *            可使一個string 也可使string數組 
     * @return 返回list的value個數 
     */  
    public Long rpush(String key, String... strs) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.rpush(key, strs);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key在list指定的位置以前或者以後 添加字符串元素 
     * </p> 
     *  
     * @param key 
     * @param where 
     *            LIST_POSITION枚舉類型 
     * @param pivot 
     *            list裏面的value 
     * @param value 
     *            添加的value 
     * @return 
     */  
    public Long linsert(String key, LIST_POSITION where, String pivot, String value) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.linsert(key, where, pivot, value);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key設置list指定下標位置的value 
     * </p> 
     * <p> 
     * 若是下標超過list裏面value的個數則報錯 
     * </p> 
     *  
     * @param key 
     * @param index 
     *            從0開始 
     * @param value 
     * @return 成功返回OK 
     */  
    public String lset(String key, Long index, String value) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lset(key, index, value);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key從對應的list中刪除指定的count個 和 value相同的元素 
     * </p> 
     *  
     * @param key 
     * @param count 
     *            當count爲0時刪除所有 
     * @param value 
     * @return 返回被刪除的個數 
     */  
    public Long lrem(String key, long count, String value) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lrem(key, count, value);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key保留list中從strat下標開始到end下標結束的value值 
     * </p> 
     *  
     * @param key 
     * @param start 
     * @param end 
     * @return 成功返回OK 
     */  
    public String ltrim(String key, long start, long end) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.ltrim(key, start, end);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key從list的頭部刪除一個value,並返回該value 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    synchronized public String lpop(String key) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lpop(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key從list尾部刪除一個value,並返回該元素 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    synchronized public String rpop(String key) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.rpop(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key從一個list的尾部刪除一個value並添加到另外一個list的頭部,並返回該value 
     * </p> 
     * <p> 
     * 若是第一個list爲空或者不存在則返回null 
     * </p> 
     *  
     * @param srckey 
     * @param dstkey 
     * @return 
     */  
    public String rpoplpush(String srckey, String dstkey) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.rpoplpush(srckey, dstkey);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key獲取list中指定下標位置的value 
     * </p> 
     *  
     * @param key 
     * @param index 
     * @return 若是沒有返回null 
     */  
    public String lindex(String key, long index) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lindex(key, index);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key返回list的長度 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    public Long llen(String key) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.llen(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key獲取list指定下標位置的value 
     * </p> 
     * <p> 
     * 若是start 爲 0 end 爲 -1 則返回所有的list中的value 
     * </p> 
     *  
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    public List<String> lrange(String key, long start, long end) {  
        Jedis jedis = null;  
        List<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.lrange(key, start, end);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key向指定的set中添加value 
     * </p> 
     *  
     * @param key 
     * @param members 
     *            能夠是一個String 也能夠是一個String數組 
     * @return 添加成功的個數 
     */  
    public Long sadd(String key, String... members) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sadd(key, members);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key刪除set中對應的value值 
     * </p> 
     *  
     * @param key 
     * @param members 
     *            能夠是一個String 也能夠是一個String數組 
     * @return 刪除的個數 
     */  
    public Long srem(String key, String... members) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.srem(key, members);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key隨機刪除一個set中的value並返回該值 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    public String spop(String key) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.spop(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key獲取set中的差集 
     * </p> 
     * <p> 
     * 以第一個set爲標準 
     * </p> 
     *  
     * @param keys 
     *            可使一個string 則返回set中全部的value 也能夠是string數組 
     * @return 
     */  
    public Set<String> sdiff(String... keys) {  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sdiff(keys);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key獲取set中的差集並存入到另外一個key中 
     * </p> 
     * <p> 
     * 以第一個set爲標準 
     * </p> 
     *  
     * @param dstkey 
     *            差集存入的key 
     * @param keys 
     *            可使一個string 則返回set中全部的value 也能夠是string數組 
     * @return 
     */  
    public Long sdiffstore(String dstkey, String... keys) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sdiffstore(dstkey, keys);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key獲取指定set中的交集 
     * </p> 
     *  
     * @param keys 
     *            可使一個string 也能夠是一個string數組 
     * @return 
     */  
    public Set<String> sinter(String... keys) {  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sinter(keys);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key獲取指定set中的交集 並將結果存入新的set中 
     * </p> 
     *  
     * @param dstkey 
     * @param keys 
     *            可使一個string 也能夠是一個string數組 
     * @return 
     */  
    public Long sinterstore(String dstkey, String... keys) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sinterstore(dstkey, keys);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key返回全部set的並集 
     * </p> 
     *  
     * @param keys 
     *            可使一個string 也能夠是一個string數組 
     * @return 
     */  
    public Set<String> sunion(String... keys) {  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sunion(keys);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key返回全部set的並集,並存入到新的set中 
     * </p> 
     *  
     * @param dstkey 
     * @param keys 
     *            可使一個string 也能夠是一個string數組 
     * @return 
     */  
    public Long sunionstore(String dstkey, String... keys) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sunionstore(dstkey, keys);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key將set中的value移除並添加到第二個set中 
     * </p> 
     *  
     * @param srckey 
     *            須要移除的 
     * @param dstkey 
     *            添加的 
     * @param member 
     *            set中的value 
     * @return 
     */  
    public Long smove(String srckey, String dstkey, String member) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.smove(srckey, dstkey, member);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key獲取set中value的個數 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    public Long scard(String key) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.scard(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key判斷value是不是set中的元素 
     * </p> 
     *  
     * @param key 
     * @param member 
     * @return 
     */  
    public Boolean sismember(String key, String member) {  
        Jedis jedis = null;  
        Boolean res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.sismember(key, member);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key獲取set中隨機的value,不刪除元素 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    public String srandmember(String key) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.srandmember(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key獲取set中全部的value 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    public Set<String> smembers(String key) {  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.smembers(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key向zset中添加value,score,其中score就是用來排序的 
     * </p> 
     * <p> 
     * 若是該value已經存在則根據score更新元素 
     * </p> 
     *  
     * @param key 
     * @param score 
     * @param member 
     * @return 
     */  
    public Long zadd(String key, double score, String member) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zadd(key, score, member);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key刪除在zset中指定的value 
     * </p> 
     *  
     * @param key 
     * @param members 
     *            可使一個string 也能夠是一個string數組 
     * @return 
     */  
    public Long zrem(String key, String... members) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrem(key, members);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key增長該zset中value的score的值 
     * </p> 
     *  
     * @param key 
     * @param score 
     * @param member 
     * @return 
     */  
    public Double zincrby(String key, double score, String member) {  
        Jedis jedis = null;  
        Double res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zincrby(key, score, member);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key返回zset中value的排名 
     * </p> 
     * <p> 
     * 下標從小到大排序 
     * </p> 
     *  
     * @param key 
     * @param member 
     * @return 
     */  
    public Long zrank(String key, String member) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrank(key, member);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key返回zset中value的排名 
     * </p> 
     * <p> 
     * 下標從大到小排序 
     * </p> 
     *  
     * @param key 
     * @param member 
     * @return 
     */  
    public Long zrevrank(String key, String member) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrevrank(key, member);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key將獲取score從start到end中zset的value 
     * </p> 
     * <p> 
     * socre從大到小排序 
     * </p> 
     * <p> 
     * 當start爲0 end爲-1時返回所有 
     * </p> 
     *  
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    public Set<String> zrevrange(String key, long start, long end) {  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrevrange(key, start, end);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key返回指定score內zset中的value 
     * </p> 
     *  
     * @param key 
     * @param max 
     * @param min 
     * @return 
     */  
    public Set<String> zrangebyscore(String key, String max, String min) {  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrevrangeByScore(key, max, min);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key返回指定score內zset中的value 
     * </p> 
     *  
     * @param key 
     * @param max 
     * @param min 
     * @return 
     */  
    public Set<String> zrangeByScore(String key, double max, double min) {  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zrevrangeByScore(key, max, min);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 返回指定區間內zset中value的數量 
     * </p> 
     *  
     * @param key 
     * @param min 
     * @param max 
     * @return 
     */  
    public Long zcount(String key, String min, String max) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zcount(key, min, max);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key返回zset中的value個數 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    public Long zcard(String key) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zcard(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key獲取zset中value的score值 
     * </p> 
     *  
     * @param key 
     * @param member 
     * @return 
     */  
    public Double zscore(String key, String member) {  
        Jedis jedis = null;  
        Double res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zscore(key, member);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key刪除給定區間內的元素 
     * </p> 
     *  
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    public Long zremrangeByRank(String key, long start, long end) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zremrangeByRank(key, start, end);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key刪除指定score內的元素 
     * </p> 
     *  
     * @param key 
     * @param start 
     * @param end 
     * @return 
     */  
    public Long zremrangeByScore(String key, double start, double end) {  
        Jedis jedis = null;  
        Long res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.zremrangeByScore(key, start, end);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 返回知足pattern表達式的全部key 
     * </p> 
     * <p> 
     * keys(*) 
     * </p> 
     * <p> 
     * 返回全部的key 
     * </p> 
     *  
     * @param pattern 
     * @return 
     */  
    public Set<String> keys(String pattern) {  
        Jedis jedis = null;  
        Set<String> res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.keys(pattern);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * <p> 
     * 經過key判斷值得類型 
     * </p> 
     *  
     * @param key 
     * @return 
     */  
    public String type(String key) {  
        Jedis jedis = null;  
        String res = null;  
        try {  
            jedis = pool.getResource();  
            res = jedis.type(key);  
        } catch (Exception e) {  

            LOGGER.error(e.getMessage());  
        } finally {  
            returnResource(pool, jedis);  
        }  
        return res;  
    }  

    /** 
     * 返還到鏈接池 
     * 
     * @param pool 
     * @param jedis 
     */  
    public static void returnResource(JedisPool pool, Jedis jedis) {  
        if (jedis != null) {  
            pool.returnResourceObject(jedis);  
        }  
    }  

    /** 
     * 返還到鏈接池 
     * 
     * @param pool 
     * @param jedis 
     */  
    public static void returnResource(Jedis jedis) {  
        if (jedis != null) {  
            pool.returnResourceObject(jedis);  
        }  
    }  
}

 

6、總結

實現步驟： 

1）初始化商品(將商品數目添加到redis中) 
2）內部類：消費者線程(模擬一個線程搶購商品：開啓redis事務，商品數量減一，提交事務，對搶到的商品作記錄) 
3）初始化秒殺操做(根據顧客數目，模擬和顧客數目相等的消費者線程) 
4）打印秒殺結果 
5）記錄程序運行時間

　　悲觀鎖實現和樂觀鎖實現大致步驟都是同樣的，惟一的區別就在消費者線程搶購商品時使用的鎖。

樂觀鎖的實現： 
　　樂觀鎖實現中的鎖就是商品的鍵值對。使用jedis的watch方法監視商品鍵值對，若是事務提交exec時發現監視的鍵值對發生變化，事務將被取消，商品數目不會被改動。

悲觀鎖實現： 
　　悲觀鎖中的鎖是一個惟一標識的鎖lockKey和該鎖的過時時間。首先肯定緩存中有商品，而後在拿數據(商品數目改動)以前先獲取到鎖，以後對商品數目進行減一操做，操做完成釋放鎖，一個秒殺操做完成。這個鎖是基於redis的setNX操做實現的阻塞式分佈式鎖。

import java.util.Set; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import redis.clients.jedis.Jedis; import test.OptimisticLockTest.ClientThread; publicclass PessimisticLockTest {publicstaticvoidmain(String[] args) { long startTime = System.currentTimeMillis(); initProduct(); initClient(); printResult(); long endTime = System.currentTimeMillis(); long time = endTime - startTime; System.out.println("程序運行時間 ： " + (int)time + "ms"); } /** * 初始化商品 * @date 2017-10-17 */publicstaticvoidinitProduct() { int prdNum = 100;//商品個數 String key = "prdNum"; String clientList = "clientList";//搶購到商品的顧客列表 Jedis jedis = RedisUtil.getInstance().getJedis(); if (jedis.exists(key)) { jedis.del(key); } if (jedis.exists(clientList)) { jedis.del(clientList); } jedis.set(key, String.valueOf(prdNum));//初始化商品 RedisUtil.returnResource(jedis); } /** * 顧客搶購商品（秒殺操做） * @date 2017-10-17 */publicstaticvoidinitClient() { ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); int clientNum = 10000;//模擬顧客數目for (int i = 0; i < clientNum; i++) { cachedThreadPool.execute(new ClientThread(i));//啓動與顧客數目相等的消費者線程 } cachedThreadPool.shutdown();//關閉線程池while (true) { if (cachedThreadPool.isTerminated()) { System.out.println("全部的消費者線程均結束了"); break; } try { Thread.sleep(100); } catch (Exception e) { // TODO: handle exception } } } /** * 打印搶購結果 * @date 2017-10-17 */publicstaticvoidprintResult() { Jedis jedis = RedisUtil.getInstance().getJedis(); Set<String> set = jedis.smembers("clientList"); int i = 1; for (String value : set) { System.out.println("第" + i++ + "個搶到商品，"+value + " "); } RedisUtil.returnResource(jedis); } /** * 消費者線程 */static class PessClientThread implements Runnable{ String key = "prdNum";//商品主鍵 String clientList = "clientList";//搶購到商品的顧客列表 String clientName; Jedis jedis = null; RedisBasedDistributedLock redisBasedDistributedLock; publicPessClientThread(int num){ clientName = "編號=" + num; init(); } publicvoidinit() { jedis = RedisUtil.getInstance().getJedis(); redisBasedDistributedLock = new RedisBasedDistributedLock(jedis, "lock.lock", 5 * 1000); } @Overridepublicvoidrun() { try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } while (true) { if (Integer.parseInt(jedis.get(key)) <= 0) { break;//緩存中沒有商品，跳出循環，消費者線程執行完畢 } //緩存中還有商品，取鎖，商品數目減一 System.out.println("顧客:" + clientName + "開始搶商品"); if (redisBasedDistributedLock.tryLock(3,TimeUnit.SECONDS)) {//等待3秒獲取鎖，不然返回false(悲觀鎖：每次拿數據都上鎖)int prdNum = Integer.parseInt(jedis.get(key));//再次取得商品緩存數目if (prdNum > 0) { jedis.decr(key);//商品數減一 jedis.sadd(clientList, clientName);//將搶購到商品的顧客記錄一下 System.out.println("恭喜，顧客:" + clientName + "搶到商品"); } else { System.out.println("抱歉，庫存爲0，顧客:" + clientName + "沒有搶到商品"); } redisBasedDistributedLock.unlock0();//操做完成釋放鎖break; } } //釋放資源 redisBasedDistributedLock = null; RedisUtil.returnResource(jedis); } } }