結合 Redis 實現同步鎖

一、技術方案

1.一、redis的基本命令

1）SETNX命令（SET if Not eXists）

語法：SETNX key value

功能：當且僅當 key 不存在，將 key 的值設爲 value ，並返回1；若給定的 key 已經存在，則 SETNX 不作任何動做，並返回0。

2）expire命令

語法：expire KEY seconds 

功能：設置key的過時時間。若是key已過時，將會被自動刪除。

3）DEL命令

語法：DEL key [KEY …]

功能：刪除給定的一個或多個 key ,不存在的 key 會被忽略。

 

1.二、實現同步鎖原理

1）加鎖：「鎖」就是一個存儲在redis裏的key-value對，key是把一組投資操做用字符串來造成惟一標識，value其實並不重要，由於只要這個惟一的key-value存在，就表示這個操做已經上鎖。 

2）解鎖：既然key-value對存在就表示上鎖，那麼釋放鎖就天然是在redis裏刪除key-value對。 

3）阻塞、非阻塞：阻塞式的實現，若線程發現已經上鎖，會在特定時間內輪詢鎖。非阻塞式的實現，若發現線程已經上鎖，則直接返回。

4）處理異常狀況：假設當投資操做調用其餘平臺接口出現等待時，天然沒有釋放鎖，這種狀況下加入鎖超時機制，用redis的expire命令爲key設置超時時長，過了超時時間redis就會將這個key自動刪除，即強制釋放鎖

（此步驟需在JAVA內部設置一樣的超時機制，內部超時時長應小於或等於redis超時時長）。

 

1.三、處理流程圖

　　   

 

二、代碼實現

2.一、同步鎖工具類

  1 package com.mic.synchrolock.util;
  2 
  3 import java.util.ArrayList;
  4 import java.util.List;
  5 import java.util.UUID;
  6 
  7 import javax.annotation.PostConstruct;
  8 import javax.annotation.PreDestroy;
  9 
 10 import org.apache.commons.logging.Log;
 11 import org.apache.commons.logging.LogFactory;
 12 
 13 import org.springframework.beans.factory.annotation.Autowired;
 14 
 15 import com.mic.constants.Constants;
 16 import com.mic.constants.InvestType;
 17 
 18 /**
 19  * 分佈式同步鎖工具類
 20  * @author Administrator
 21  *
 22  */
 23 public class SynchrolockUtil {    
 24     
 25     private final Log logger = LogFactory.getLog(getClass());
 26     
 27     @Autowired
 28     private RedisClientTemplate redisClientTemplate;
 29 
 30     public final String RETRYTYPE_WAIT = "1";     //加鎖方法當對象已加鎖時，設置爲等待並輪詢
 31     public final String RETRYTYPE_NOWAIT = "0";     //加鎖方法當對象已加鎖時，設置爲直接返回
 32     
 33     private String requestTimeOutName = "";     //投資同步鎖請求超時時間
 34     private String retryIntervalName = "";         //投資同步鎖輪詢間隔
 35     private String keyTimeoutName = "";        //緩存中key的失效時間
 36     private String investProductSn = "";         //產品Sn
 37     private String uuid;                //對象惟一標識
 38     
 39     private Long startTime = System.currentTimeMillis(); //首次調用時間
 40     public Long getStartTime() {
 41         return startTime;
 42     }
 43 
 44     List<String> keyList = new ArrayList<String>();    //緩存key的保存集合
 45     public List<String> getKeyList() {
 46         return keyList;
 47     }
 48     public void setKeyList(List<String> keyList) {
 49         this.keyList = keyList;
 50     }
 51 
 52     @PostConstruct
 53     public void init() {
 54         uuid = UUID.randomUUID().toString();
 55     }
 56     
 57     @PreDestroy
 58     public void destroy() {
 59         this.unlock();
 60     }
 61     
 62 
 63     /**
 64      * 根據傳入key值，判斷緩存中是否存在該key
 65      * 存在-已上鎖：判斷retryType，輪詢超時，或直接返回，返回ture
 66      * 不存在-未上鎖：將該放入緩存，返回false
 67      * @param key
 68      * @param retryType 當遇到上鎖狀況時  1：輪詢；0：直接返回
 69      * @return
 70      */
 71     public boolean islocked(String key,String retryType){
 72         boolean flag = true;
 73         logger.info("====投資同步鎖設置輪詢間隔、請求超時時長、緩存key失效時長====");
 74         //投資同步鎖輪詢間隔 毫秒
 75         Long retryInterval = Long.parseLong(Constants.getProperty(retryIntervalName));
 76         //投資同步鎖請求超時時間 毫秒
 77         Long requestTimeOut = Long.parseLong(Constants.getProperty(requestTimeOutName));
 78         //緩存中key的失效時間 秒
 79         Integer keyTimeout =  Integer.parseInt(Constants.getProperty(keyTimeoutName));
 80         
 81         //調用緩存獲取當前產品鎖
 82         logger.info("====當前產品key爲："+key+"====");
 83         if(isLockedInRedis(key,keyTimeout)){
 84             if("1".equals(retryType)){
 85                 //採用輪詢方式等待
 86                 while (true) {
 87                     logger.info("====產品已被佔用，開始輪詢====");
 88                     try {
 89                         Thread.sleep(retryInterval);
 90                     } catch (InterruptedException e) {
 91                         logger.error("線程睡眠異常:"+e.getMessage(), e);
 92                         return flag;
 93                     }
 94                     logger.info("====判斷請求是否超時====");
 95                     Long currentTime = System.currentTimeMillis(); //當前調用時間
 96                     long Interval = currentTime - startTime;
 97                     if (Interval > requestTimeOut) {
 98                         logger.info("====請求超時====");
 99                         return flag;
100                     }
101                     if(!isLockedInRedis(key,keyTimeout)){
102                         logger.info("====輪詢結束，添加同步鎖====");
103                         flag = false;
104                         keyList.add(key);
105                         break;
106                     }
107                 }
108             }else{
109                 //不等待，直接返回
110                 logger.info("====產品已被佔用，直接返回====");
111                 return flag;
112             }
113             
114         }else{
115             logger.info("====產品未被佔用，添加同步鎖====");
116             flag = false;
117             keyList.add(key);
118         }
119         return flag;
120     }
121     
122     /**
123      * 在緩存中查詢key是否存在
124      * 若存在則返回true;
125      * 若不存在則將key放入緩存，設置過時時間，返回false
126      * @param key
127      * @param keyTimeout key超時時間單位是秒
128      * @return
129      */
130     boolean isLockedInRedis(String key,int keyTimeout){
131         logger.info("====在緩存中查詢key是否存在====");
132         boolean isExist = false; 
133         //與redis交互，查詢對象是否上鎖
134         Long result = this.redisClientTemplate.setnx(key, uuid);
135         logger.info("====上鎖 result = "+result+"====");
136         if(null != result && 1 == Integer.parseInt(result.toString())){
137             logger.info("====設置緩存失效時長 = "+keyTimeout+"秒====");
138             this.redisClientTemplate.expire(key, keyTimeout);
139             logger.info("====上鎖成功====");
140             isExist = false;
141         }else{
142             logger.info("====上鎖失敗====");
143             isExist = true;
144         }
145         return isExist;
146     }
147     
148     /**
149      * 根據傳入key，對該產品進行解鎖
150      * @param key
151      * @return
152      */
153     public void unlock(){
154         //與redis交互，對產品解鎖
155         if(keyList.size()>0){
156             for(String key : this.keyList){
157                 String value = this.redisClientTemplate.get(key);
158                 if(null != value && !"".equals(value)){
159                     if(uuid.equals(value)){
160                         logger.info("====解鎖key:"+key+" value="+value+"====");
161                         this.redisClientTemplate.del(key);
162                     }else{
163                         logger.info("====待解鎖集合中key:"+key+" value="+value+"與uuid不匹配====");
164                     }
165                 }else{
166                     logger.info("====待解鎖集合中key="+key+"的value爲空====");
167                 }
168             }
169         }else{
170             logger.info("====待解鎖集合爲空====");
171         }
172     }
173     
174     
175 }

 

2.二、業務調用模擬樣例

 1 　　//獲取同步鎖工具類
 2 　　SynchrolockUtil synchrolockUtil = SpringUtils.getBean("synchrolockUtil");
 3 　　//獲取需上鎖資源的KEY
 4 　　String key = "abc";
 5 　　//查詢是否上鎖，上鎖輪詢，未上鎖加鎖
 6 　　boolean isLocked = synchrolockUtil.islocked(key,synchrolockUtil.RETRYTYPE_WAIT);
 7 　　//判斷上鎖結果
 8 　　if(isLocked){
 9    　　logger.error("同步鎖請求超時並返回 key ="+key);
10 　　}else{
11     　　logger.info("====同步鎖加鎖陳功====");
12 　　}
13 
14 　　try {
15 
16     　　//執行業務處理
17 
18 　　} catch (Exception e) {
19     　　logger.error("業務異常:"+e.getMessage(), e);
20 　　}finally{
21     　　//解鎖
22    　　 synchrolockUtil.unlock();
23 　　}

 

2.三、若是業務處理內部，還有嵌套加鎖需求，只需將對象傳入方法內部，加鎖成功後將key值追加到集合中便可

 

ps：實際實現中還須要jedis工具類，需額外添加調用