Redis分佈式鎖----悲觀鎖實現,以秒殺系統爲例

時間 2019-11-11

原文原文鏈接

摘要：本文要實現的是一種使用redis來實現分佈式鎖。java

一、分佈式鎖git

分佈式鎖在是一種用來安全訪問分式式機器上變量的安全方案，通常用在全局id生成，秒殺系統，全局變量共享、分佈式事務等。通常會有兩種實現方案，一種是悲觀鎖的實現，一種是樂觀鎖的實現。悲觀鎖的併發性能差，可是能保證不會發生髒數據的可能性小一點。github

二、Redis命令介紹
使用Redis實現分佈式鎖，有兩個重要函數須要介紹

SETNX命令（SET if Not eXists）
語法：
SETNX key value
功能：
當且僅當 key 不存在，將 key 的值設爲 value ，並返回1；若給定的 key 已經存在，則 SETNX 不作任何動做，並返回0。

GETSET命令（這是一個原子命令！）
語法：
GETSET key value
功能：
將給定 key 的值設爲 value ，並返回 key 的舊值 (old value)，當 key 存在但不是字符串類型時，返回一個錯誤，當key不存在時，返回nil。

GET命令
語法：
GET key
功能：
返回 key 所關聯的字符串值，若是 key 不存在那麼返回特殊值 nil 。

DEL命令
語法：
DEL key [KEY …]
功能：
刪除給定的一個或多個 key ,不存在的 key 會被忽略。

三、代碼實現redis

（1）AbstractLock基類數組

package com.github.distribute.lock.redis;

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;

}

（2）、實現類緩存

package com.github.distribute.lock.redis;

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 lockExpires;

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

    // 阻塞式獲取鎖的實現
    protected boolean lock(boolean useTimeout, long time, TimeUnit unit, boolean interrupt) throws InterruptedException {
        System.out.println("test1");
        if (interrupt) {
            checkInterruption();
        }

        System.out.println("test2");
        long start = System.currentTimeMillis();
        long timeout = unit.toMillis(time); // if !useTimeout, then it's useless

        while (useTimeout ? isTimeout(start, timeout) : true) {
            System.out.println("test3");
            if (interrupt) {
                checkInterruption();
            }

            long lockExpireTime = System.currentTimeMillis() + lockExpires + 1;// 鎖超時時間
            String stringOfLockExpireTime = String.valueOf(lockExpireTime);

            System.out.println("test4");
            if (jedis.setnx(lockKey, stringOfLockExpireTime) == 1) { // 獲取到鎖
                System.out.println("test5");
                //成功獲取到鎖, 設置相關標識
                locked = true;
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }

            System.out.println("test6");
            String value = jedis.get(lockKey);
            if (value != null && isTimeExpired(value)) { // lock is expired
                System.out.println("test7");
                // 假設多個線程(非單jvm)同時走到這裏
                String oldValue = jedis.getSet(lockKey, stringOfLockExpireTime); //原子操做
                // 可是走到這裏時每一個線程拿到的oldValue確定不可能同樣(由於getset是原子性的)
                // 加入拿到的oldValue依然是expired的，那麼就說明拿到鎖了
                System.out.println("test8");
                if (oldValue != null && isTimeExpired(oldValue)) {
                    System.out.println("test9");
                    //成功獲取到鎖, 設置相關標識
                    locked = true;
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
            } else {
                // TODO lock is not expired, enter next loop retrying
            }
        }
        System.out.println("test10");
        return false;
    }

    public boolean tryLock() {
        long lockExpireTime = System.currentTimeMillis() + lockExpires + 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)) { // lock is expired
            // 假設多個線程(非單jvm)同時走到這裏
            String oldValue = jedis.getSet(lockKey, stringOfLockExpireTime); //原子操做
            // 可是走到這裏時每一個線程拿到的oldValue確定不可能同樣(由於getset是原子性的)
            // 假如拿到的oldValue依然是expired的，那麼就說明拿到鎖了
            if (oldValue != null && isTimeExpired(oldValue)) {
                //成功獲取到鎖, 設置相關標識
                locked = true;
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
        } else {
            // TODO lock is not expired, enter next loop retrying
        }

        return false;
    }

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

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

    private void checkInterruption() throws InterruptedException {
        if (Thread.currentThread().isInterrupted()) {
            throw new InterruptedException();
        }
    }

    private boolean isTimeExpired(String value) {
        return Long.parseLong(value) < System.currentTimeMillis();
    }

    private boolean isTimeout(long start, long timeout) {
        return start + timeout > System.currentTimeMillis();
    }

    private void doUnlock() {
        jedis.del(lockKey);
    }

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

}

原理其實很簡單，就是利用setNx和getSet這兩個命令來實現。安全

SetNx若是返回爲1，表示拿到鎖，並設置超時失效時間。併發

getSet是一個原子操做，它是在鎖超時後沒釋放會進入，這時有可能多個應用一同時進入，可是若是設置成功，會返回oldValue，若是兩個oldvalue同樣，代表拿到鎖了app

上面使用到的redis工具類less

package com.github.distribute.lock.redis;

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.75.202.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);
        }
    }
}

四、測試

寫了一個簡單的秒殺系統的模擬

package com.github.distribute.lock.redis;

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

import redis.clients.jedis.Jedis;

public class PessimisticLockTest {

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

    /**
     * 輸出結果
     */
    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);
    }

    /*
     * 初始化顧客開始搶商品
     */
    public static void initClient() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        int clientNum = 10000;// 模擬客戶數目
        for (int i = 0; i < clientNum; i++) {
            cachedThreadPool.execute(new PessClientThread(i));
        }
        cachedThreadPool.shutdown();

        while (true) {
            if (cachedThreadPool.isTerminated()) {
                System.out.println("全部的線程都結束了！");
                break;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 初始化商品個數
     */
    public static void initPrduct() {
        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);
    }

}

/**
 * 顧客線程
 * 
 * @author linbingwen
 *
 */
class PessClientThread implements Runnable {
    String key = "prdNum";// 商品主鍵
    String clientList = "clientList";// // 搶購到商品的顧客列表主鍵
    String clientName;
    RedisBasedDistributedLock redisBasedDistributedLock;
    Jedis jedis = null;

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

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

    public void run() {
        try {
            Thread.sleep((int) (Math.random() * 5000));// 隨機睡眠一下
        } catch (InterruptedException e1) {
        }

        while (true) {
            //先判斷緩存是否有商品
            if(Integer.valueOf(jedis.get(key))<= 0) {
                break;
            }
            
            //緩存還有商品，取鎖，商品數目減去1
            System.out.println("顧客:" + clientName + "開始搶商品");
            if (redisBasedDistributedLock.tryLock(3,TimeUnit.SECONDS)) { //等待3秒獲取鎖，不然返回false
                int prdNum = Integer.valueOf(jedis.get(key)); //再次取得商品緩存數目
                if (prdNum > 0) {
                    jedis.decr(key);//商品數減1
                    jedis.sadd(clientList, clientName);// 搶到商品記錄一下
                    System.out.println("好高興，顧客:" + clientName + "搶到商品");
                } else {
                    System.out.println("悲劇了，庫存爲0，顧客:" + clientName + "沒有搶到商品");
                }
                redisBasedDistributedLock.unlock();
                break;
            }
        }
        //釋放資源
        redisBasedDistributedLock = null;
        RedisUtil.returnResource(jedis);
    }

}