一、業務場景
所謂秒殺，從業務角度看，是短時間內多個用戶“爭搶”資源，這里的資源在大部分秒殺場景里是商品；將業務抽象，技術角度看，秒殺就是多個線程對資源進行操作，所以實現秒殺，就必須控制線程對資源的爭搶，既要保證高效並發，也要保證操作的正確。
二、一些可能的實現
剛才提到過，實現秒殺的關鍵點是控制線程對資源的爭搶，根據基本的線程知識，可以不加思索的想到下面的一些方法：
1)、秒殺在技術層面的抽象應該就是一個方法，在這個方法里可能的操作是將商品庫存-1，將商品加入用戶的購物車等等，在不考慮緩存的情況下應該是要操作數據庫的。那么最簡單直接的實現就是在這個方法上加上synchronized關鍵字，通俗的講就是鎖住整個方法；
2)、鎖住整個方法這個策略簡單方便，但是似乎有點粗暴。可以稍微優化一下，只鎖住秒殺的代碼塊，比如寫數據庫的部分；
3)、既然有並發問題，那我就讓他“不並發”，將所有的線程用一個隊列管理起來，使之變成串行操作，自然不會有並發問題。
上面所述的方法都是有效的，但是都不好。為什么？第一和第二種方法本質上是“加鎖”，但是鎖粒度依然比較高。什么意思？試想一下，如果兩個線程同時執行秒殺方法，這兩個線程操作的是不同的商品,從業務上講應該是可以同時進行的，但是如果采用第一二種方法，這兩個線程也會去爭搶同一個鎖，這其實是不必要的。第三種方法也沒有解決上面說的問題。
那么如何將鎖控制在更細的粒度上呢？可以考慮為每個商品設置一個互斥鎖，以和商品ID相關的字符串為唯一標識，這樣就可以做到只有爭搶同一件商品的線程互斥，不會導致所有的線程互斥。分布式鎖恰好可以幫助我們解決這個問題。
三、具體的實現
需要考慮的問題
1、用什么操作redis？幸虧redis已經提供了jedis客戶端用於java應用程序，直接調用jedis API即可。
2、怎么實現加鎖？“鎖”其實是一個抽象的概念，將這個抽象概念變為具體的東西，就是一個存儲在redis里的key-value對，key是於商品ID相關的字符串來唯一標識，value其實並不重要，因為只要這個唯一的key-value存在，就表示這個商品已經上鎖。
3、如何釋放鎖？既然key-value對存在就表示上鎖，那么釋放鎖就自然是在redis里刪除key-value對。
4、阻塞還是非阻塞？筆者采用了阻塞式的實現，若線程發現已經上鎖，會在特定時間內輪詢鎖。
5、如何處理異常情況？比如一個線程把一個商品上了鎖，但是由於各種原因，沒有完成操作（在上面的業務場景里就是沒有將庫存-1寫入數據庫），自然沒有釋放鎖，這個情況筆者加入了鎖超時機制，利用redis的expire命令為key設置超時時長，過了超時時間redis就會將這個key自動刪除，即強制釋放鎖（可以認為超時釋放鎖是一個異步操作，由redis完成，應用程序只需要根據系統特點設置超時時間即可）。
四、樂觀鎖實現秒殺系統
我們知道大多數是基於數據版本（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); } } } } }
五、悲觀鎖實現秒殺系統
實現秒殺的類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); } } }
六、總結
實現步驟：
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); } } }