2. 程式人生 > >Redis分散式鎖升級版RedLock及SpringBoot實現

Redis分散式鎖升級版RedLock及SpringBoot實現

阿新 • • 發佈：2021-02-01
## 分散式鎖概覽 在多執行緒的環境下，為了保證一個程式碼塊在同一時間只能由一個執行緒訪問，Java中我們一般可以使用synchronized語法和ReetrantLock去保證，這實際上是本地鎖的方式。但是現在公司都是流行分散式架構，在分散式環境下，如何保證不同節點的執行緒同步執行呢？因此就引出了分散式鎖，它是控制分散式系統之間**互斥訪問共享資源**的一種方式。 在一個分散式系統中，多臺機器上部署了多個服務，當客戶端一個使用者發起一個數據插入請求時，如果沒有分散式鎖機制保證，那麼那多臺機器上的多個服務可能進行併發插入操作，導致資料重複插入，對於某些不允許有多餘資料的業務來說，這就會造成問題。而分散式鎖機制就是為了解決類似這類問題，保證多個服務之間互斥的訪問共享資源，如果一個服務搶佔了分散式鎖，其他服務沒獲取到鎖，就不進行後續操作。大致意思如下圖所示： ![](https://img2020.cnblogs.com/blog/2002319/202102/2002319-20210201105847276-987080352.png) ## 分散式鎖的特點 分散式鎖一般有如下的特點： - 互斥性： 同一時刻只能有一個執行緒持有鎖 - 可重入性： 同一節點上的同一個執行緒如果獲取了鎖之後能夠再次獲取鎖 - 鎖超時：和J.U.C中的鎖一樣支援鎖超時，防止死鎖 - 高效能和高可用： 加鎖和解鎖需要高效，同時也需要保證高可用，防止分散式鎖失效 - 具備阻塞和非阻塞性：能夠及時從阻塞狀態中被喚醒 ## 分散式鎖的實現方式 我們一般實現分散式鎖有以下幾種方式： - 基於資料庫 - 基於Redis - 基於zookeeper ## ## Redis普通分散式鎖存在的問題 說到Redis分散式鎖,大部分人都會想到：`setnx+lua`（redis保證執行lua指令碼時不執行其他操作，保證操作的原子性），或者知道`set key value px milliseconds nx`。後一種方式的核心實現命令如下： ```lua - 獲取鎖（unique_value可以是UUID等） SET resource_name unique_value NX PX 30000 - 釋放鎖（lua指令碼中，一定要比較value，防止誤解鎖） if redis.call("get",KEYS[1]) == ARGV[1] then return redis.call("del",KEYS[1]) else return 0 end ``` 這種實現方式有3大要點（也是面試概率非常高的地方）： >1. set命令要用`set key value px milliseconds nx`； >2. value要具有唯一性； >3. 釋放鎖時要驗證value值，不能誤解鎖； 事實上這類鎖最大的缺點就是它加鎖時只作用在一個Redis節點上，即使Redis通過sentinel保證高可用，如果這個master節點由於某些原因發生了主從切換，那麼就會出現鎖丟失的情況： >1. 在Redis的master節點上拿到了鎖； >2. 但是這個加鎖的key還沒有同步到slave節點； >3. master故障，發生故障轉移，slave節點升級為master節點； >4. 導致鎖丟失。 為了避免單點故障問題，Redis作者antirez基於分散式環境下提出了一種更高階的分散式鎖的實現方式：**Redlock**。Redlock也是Redis所有分散式鎖實現方式中唯一能讓面試官高潮的方式。 ## Redis高階分散式鎖:Redlock antirez提出的redlock演算法大概是這樣的： 在Redis的分散式環境中，我們假設有N個Redis master。這些節點**完全互相獨立，不存在主從複製或者其他叢集協調機制**。我們確保將在N個例項上使用與在Redis單例項下相同方法獲取和釋放鎖。現在我們假設有5個Redis master節點，同時我們需要在5臺伺服器上面執行這些Redis例項，這樣保證他們不會同時都宕掉。 為了取到鎖，客戶端應該執行以下操作: - 獲取當前Unix時間，以毫秒為單位。 - 依次嘗試從5個例項，使用相同的key和**具有唯一性的value**（例如UUID）獲取鎖。當向Redis請求獲取鎖時，客戶端應該設定一個網路連線和響應超時時間，這個超時時間應該小於鎖的失效時間。例如你的鎖自動失效時間**TTL**為10秒，則超時時間應該在5-50毫秒之間。這樣可以避免伺服器端Redis已經掛掉的情況下，客戶端還在死死地等待響應結果。如果伺服器端沒有在規定時間內響應，客戶端應該儘快嘗試去另外一個Redis例項請求獲取鎖。 - 客戶端使用當前時間減去開始獲取鎖時間（步驟1記錄的時間）就得到獲取鎖使用的時間。**當且僅當從大多數**（N/2+1，這裡是3個節點）**的Redis節點都取到鎖，並且使用的時間小於鎖失效時間時，鎖才算獲取成功**。 - 如果取到了鎖，key的真正有效時間等於有效時間減去獲取鎖所使用的時間（步驟3計算的結果）。 - 如果因為某些原因，獲取鎖失敗（沒有在至少N/2+1個Redis例項取到鎖或者取鎖時間已經超過了有效時間），客戶端應該在**所有的Redis例項上進行解鎖**（即便某些Redis例項根本就沒有加鎖成功，防止某些節點獲取到鎖但是客戶端沒有得到響應而導致接下來的一段時間不能被重新獲取鎖）。 - 此處不討論時鐘漂移 ![](https://img2020.cnblogs.com/blog/2002319/202102/2002319-20210201105903472-1874316084.png) ## Redlock原始碼 redisson已經有對redlock演算法封裝，接下來對其用法進行簡單介紹，並對核心原始碼進行分析（假設5個redis例項）。 ### 1. Redlock依賴 ```java
org.redisson redisson 3.3.2 ``` ### 2. Redlock用法 首先，我們來看一下redission封裝的redlock演算法實現的分散式鎖用法，非常簡單，跟重入鎖（ReentrantLock）有點類似： ```java Config config = new Config(); config.useSentinelServers().addSentinelAddress("127.0.0.1:6369","127.0.0.1:6379", "127.0.0.1:6389") .setMasterName("masterName") .setPassword("password").setDatabase(0); RedissonClient redissonClient = Redisson.create(config); // 還可以getFairLock(), getReadWriteLock() RLock redLock = redissonClient.getLock("REDLOCK_KEY"); boolean isLock; try { isLock = redLock.tryLock(); // 500ms拿不到鎖, 就認為獲取鎖失敗。10000ms即10s是鎖失效時間。 isLock = redLock.tryLock(500, 10000, TimeUnit.MILLISECONDS); if (isLock) { //TODO if get lock success, do something; } } catch (Exception e) { } finally { // 無論如何, 最後都要解鎖 redLock.unlock(); } ``` ### 3. Redlock唯一ID 實現分散式鎖的一個非常重要的點就是set的value要具有唯一性，redisson的value是怎樣保證value的唯一性呢？答案是**UUID+threadId**。入口在redissonClient.getLock("REDLOCK_KEY")，原始碼在Redisson.java和RedissonLock.java中： ```java protected final UUID id = UUID.randomUUID(); String getLockName(long threadId) { return id + ":" + threadId; } ``` ### 4. Redlock獲取鎖 獲取鎖的程式碼為redLock.tryLock()或者redLock.tryLock(500, 10000, TimeUnit.MILLISECONDS)，兩者的最終核心原始碼都是下面這段程式碼，只不過前者獲取鎖的預設租約時間（leaseTime）是LOCK_EXPIRATION_INTERVAL_SECONDS，即30s： ```java RFuture tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand command) { internalLockLeaseTime = unit.toMillis(leaseTime); // 獲取鎖時向5個redis例項傳送的命令 return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command, // 首先分散式鎖的KEY不能存在，如果確實不存在，那麼執行hset命令（hset REDLOCK_KEY uuid+threadId 1），並通過pexpire設定失效時間（也是鎖的租約時間） "if (redis.call('exists', KEYS[1]) == 0) then " + "redis.call('hset', KEYS[1], ARGV[2], 1); " + "redis.call('pexpire', KEYS[1], ARGV[1]); " + "return nil; " + "end; " + // 如果分散式鎖的KEY已經存在，並且value也匹配，表示是當前執行緒持有的鎖，那麼重入次數加1，並且設定失效時間 "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " + "redis.call('hincrby', KEYS[1], ARGV[2], 1); " + "redis.call('pexpire', KEYS[1], ARGV[1]); " + "return nil; " + "end; " + // 獲取分散式鎖的KEY的失效時間毫秒數 "return redis.call('pttl', KEYS[1]);", // 這三個引數分別對應KEYS[1]，ARGV[1]和ARGV[2] Collections.singletonList(getName()), internalLockLeaseTime, getLockName(threadId)); } ``` 獲取鎖的命令中， - **KEYS[1]**就是Collections.singletonList(getName())，表示分散式鎖的key，即REDLOCK_KEY； - **ARGV[1]**就是internalLockLeaseTime，即鎖的租約時間，預設30s； - **ARGV[2]**就是getLockName(threadId)，是獲取鎖時set的唯一值，即UUID+threadId： ### 5. Redlock釋放鎖 釋放鎖的程式碼為redLock.unlock()，核心原始碼如下： ```java protected RFuture unlockInnerAsync(long threadId) { // 向5個redis例項都執行如下命令 return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN, // 如果分散式鎖KEY不存在，那麼向channel釋出一條訊息 "if (redis.call('exists', KEYS[1]) == 0) then " + "redis.call('publish', KEYS[2], ARGV[1]); " + "return 1; " + "end;" + // 如果分散式鎖存在，但是value不匹配，表示鎖已經被佔用，那麼直接返回 "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " + "return nil;" + "end; " + // 如果就是當前執行緒佔有分散式鎖，那麼將重入次數減1 "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " + // 重入次數減1後的值如果大於0，表示分散式鎖有重入過，那麼只設置失效時間，還不能刪除 "if (counter > 0) then " + "redis.call('pexpire', KEYS[1], ARGV[2]); " + "return 0; " + "else " + // 重入次數減1後的值如果為0，表示分散式鎖只獲取過1次，那麼刪除這個KEY，併發布解鎖訊息 "redis.call('del', KEYS[1]); " + "redis.call('publish', KEYS[2], ARGV[1]); " + "return 1; "+ "end; " + "return nil;", // 這5個引數分別對應KEYS[1]，KEYS[2]，ARGV[1]，ARGV[2]和ARGV[3] Arrays.asList(getName(), getChannelName()), LockPubSub.unlockMessage, internalLockLeaseTime, getLockName(threadId)); } ``` ## Redis實現的分散式鎖輪子 下面利用SpringBoot + Jedis + AOP的組合來實現一個簡易的分散式鎖。 ### 1. 自定義註解 自定義一個註解，被註解的方法會執行獲取分散式鎖的邏輯 ```java @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited public @interface RedisLock { /** * 業務鍵 * * @return */ String key(); /** * 鎖的過期秒數,預設是5秒 * * @return */ int expire() default 5; /** * 嘗試加鎖，最多等待時間 * * @return */ long waitTime() default Long.MIN_VALUE; /** * 鎖的超時時間單位 * * @return */ TimeUnit timeUnit() default TimeUnit.SECONDS; } ``` ### 2. AOP攔截器實現 在AOP中我們去執行獲取分散式鎖和釋放分散式鎖的邏輯，程式碼如下： ```java @Aspect @Component public class LockMethodAspect { @Autowired private RedisLockHelper redisLockHelper; @Autowired private JedisUtil jedisUtil; private Logger logger = LoggerFactory.getLogger(LockMethodAspect.class); @Around("@annotation(com.redis.lock.annotation.RedisLock)") public Object around(ProceedingJoinPoint joinPoint) { Jedis jedis = jedisUtil.getJedis(); MethodSignature signature = (MethodSignature) joinPoint.getSignature(); Method method = signature.getMethod(); RedisLock redisLock = method.getAnnotation(RedisLock.class); String value = UUID.randomUUID().toString(); String key = redisLock.key(); try { final boolean islock = redisLockHelper.lock(jedis,key, value, redisLock.expire(), redisLock.timeUnit()); logger.info("isLock : {}",islock); if (!islock) { logger.error("獲取鎖失敗"); throw new RuntimeException("獲取鎖失敗"); } try { return joinPoint.proceed(); } catch (Throwable throwable) { throw new RuntimeException("系統異常"); } } finally { logger.info("釋放鎖"); redisLockHelper.unlock(jedis,key, value); jedis.close(); } } } ``` ### 3. Redis實現分散式鎖核心類 ```java @Component public class RedisLockHelper { private long sleepTime = 100; /** * 直接使用setnx + expire方式獲取分散式鎖 * 非原子性 * * @param key * @param value * @param timeout * @return */ public boolean lock_setnx(Jedis jedis,String key, String value, int timeout) { Long result = jedis.setnx(key, value); // result = 1時，設定成功，否則設定失敗 if (result == 1L) { return jedis.expire(key, timeout) == 1L; } else { return false; } } /** * 使用Lua指令碼，指令碼中使用setnex+expire命令進行加鎖操作 * * @param jedis * @param key * @param UniqueId * @param seconds * @return */ public boolean Lock_with_lua(Jedis jedis,String key, String UniqueId, int seconds) { String lua_scripts = "if redis.call('setnx',KEYS[1],ARGV[1]) == 1 then" + "redis.call('expire',KEYS[1],ARGV[2]) return 1 else return 0 end"; List keys = new ArrayList<>(); List values = new ArrayList<>(); keys.add(key); values.add(UniqueId); values.add(String.valueOf(seconds)); Object result = jedis.eval(lua_scripts, keys, values); //判斷是否成功 return result.equals(1L); } /** * 在Redis的2.6.12及以後中,使用 set key value [NX] [EX] 命令 * * @param key * @param value * @param timeout * @return */ public boolean lock(Jedis jedis,String key, String value, int timeout, TimeUnit timeUnit) { long seconds = timeUnit.toSeconds(timeout); return "OK".equals(jedis.set(key, value, "NX", "EX", seconds)); } /** * 自定義獲取鎖的超時時間 * * @param jedis * @param key * @param value * @param timeout * @param waitTime * @param timeUnit * @return * @throws InterruptedException */ public boolean lock_with_waitTime(Jedis jedis,String key, String value, int timeout, long waitTime,TimeUnit timeUnit) throws InterruptedException { long seconds = timeUnit.toSeconds(timeout); while (waitTime >= 0) { String result = jedis.set(key, value, "nx", "ex", seconds); if ("OK".equals(result)) { return true; } waitTime -= sleepTime; Thread.sleep(sleepTime); } return false; } /** * 錯誤的解鎖方法—直接刪除key * * @param key */ public void unlock_with_del(Jedis jedis,String key) { jedis.del(key); } /** * 使用Lua指令碼進行解鎖操縱，解鎖的時候驗證value值 * * @param jedis * @param key * @param value * @return */ public boolean unlock(Jedis jedis,String key,String value) { String luaScript = "if redis.call('get',KEYS[1]) == ARGV[1] then " + "return redis.call('del',KEYS[1]) else return 0 end"; return jedis.eval(luaScript, Collections.singletonList(key), Collections.singletonList(value)).equals(1L); } } ``` ### 4. Controller層控制 定義一個TestController來測試我們實現的分散式鎖 ```java @RestController public class TestController { @RedisLock(key = "redis_lock") @GetMapping("/index") public String index() { return "index"; } } ``` ## 站在巨人的肩膀上 [1.Redlock：Redis分散式鎖最牛逼的實現](https://mp.weixin.qq.com/s?__biz=MzU5ODUwNzY1Nw==&mid=2247484155&idx=1&sn=0c73f45f2f641ba0bf4399f57170ac9b&scene=21#wechat_redirect) [2.基於Redis的分散式鎖實現](https://juejin.cn/post/6844903830442

相關推薦

Redis分散式鎖升級版RedLock及SpringBoot實現

## 分散式鎖概覽 在多執行緒的環境下，為了保證一個程式碼塊在同一時間只能由一個執行緒訪問，Java中我們一般可以使用synchronized語法和ReetrantLock去保證，這實際上是本地鎖的方式。但是現在公司都是流行分散式架構，在分散式環境下，如何保證不同節點的執行緒同步執行呢？因此就引出了分散

Redlock：Redis分散式鎖最牛逼的實現

普通實現 說道Redis分散式鎖大部分人都會想到： setnx+lua，或者知道 setkey value px milliseconds nx。後一種方式的核心實現命令如下： - 獲取鎖（unique_value可以是UUID等） SET resource_name unique_v

Redis 分散式鎖的正確實現方式（ Java 版 ）

前言 分散式鎖一般有三種實現方式：1. 資料庫樂觀鎖；2. 基於Redis的分散式鎖；3. 基於ZooKeeper的分散式鎖。本篇部落格將介紹第二種方式，基於Redis實現分散式鎖。雖然網上已經有各種介紹Redis分散式鎖實現的部落格，然而他們的實現卻有著各種各樣的問題，為

基於Redis分散式鎖（獲取鎖及解鎖）

　　目前幾乎很多大型網站及應用都是分散式部署的，分散式場景中的資料一致性問題一直是一個比較重要的話題。分散式的CAP理論告訴我們“任何一個分散式系統都無法同時滿足一致性(Consistency)、可用性(Availability)和分割槽容錯性(Partition tolerance)，最多隻能同時滿足兩項。

Redis】SpringBoot整合Redis分散式鎖以及Redis快取

整合Redis 首先在pom.xml中加入需要的redis依賴和快取依賴 <!-- 引入redis依賴 --> <dependency>     <groupId>org.springframework.boot</grou

Redis分散式鎖的正確實現方式（Java版）

前言 分散式鎖一般有三種實現方式：1. 資料庫樂觀鎖；2. 基於Redis的分散式鎖；3. 基於ZooKeeper的分散式鎖。本篇部落格將介紹第二種方式，基於Redis實現分散式鎖。雖然網上已經有各種介紹Redis分散式鎖實現的部落格，然而他們的實現卻有著各種各樣的問題

高併發架構系列：分散式鎖的由來、特點及Redis分散式鎖的實現詳解

標題Redis記憶體回收機制 Redis的記憶體回收主要圍繞以下兩個方面： 1.Redis過期策略 刪除過期時間的key值 2.Redis淘汰策略 記憶體使用到達maxmemory上限時觸發記憶體淘汰資料 Redis的過期策略和記憶體淘汰策略不是一件事，實際研發中不要弄混淆了

Redis分散式鎖的正確實現方式(Java版)

分散式鎖一般有三種實現方式：1. 資料庫樂觀鎖；2. 基於Redis的分散式鎖；3. 基於ZooKeeper的分散式鎖。本篇部落格將介紹第二種方式，基於Redis實現分散式鎖。雖然網上已經有各種介紹Redis分散式鎖實現的部落格，然而他們的實現卻有著各種各樣的問題，為了避免誤人子弟，本篇部落格將詳細介紹如

redis分散式鎖的實現及問題分析

$redLock = new RedLock($servers); 然後鎖住一個鍵，並且設定鎖住的時間。時間是以毫秒為單位的。 $lock = $redLock->lock('my_resource_name', 1000); 如果失敗返回false，成功則會返回以下資料： Array(

Redis 分散式鎖的正確實現方式（ Java 版 ）[轉]

分散式鎖一般有三種實現方式：1. 資料庫樂觀鎖；2. 基於Redis的分散式鎖；3. 基於ZooKeeper的分散式鎖。本篇部落格將介紹第二種方式，基於Redis實現分散式鎖。雖然網上已經有各種介紹Redis分散式鎖實現的部落格，然而他們的實現卻有著各種各樣的問題，為了避

Redis 分散式鎖的正確實現方式- Java 版

前言分散式鎖一般有三種實現方式：1. 資料庫樂觀鎖；2. 基於Redis的分散式鎖；3. 基於ZooKeeper的分散式鎖。本篇部落格將介紹第二種方式，基於Redis實現分散式鎖。雖然網上已經有各種介紹Redis分散式鎖實現的部落格，然而他們的實現卻有著各種各樣的問題，為了避

Redis分散式鎖實現原理 java版

/** * 鎖在給定的等待時間內空閒，則獲取鎖成功 返回true， 否則返回false * @param subKey * @param timeout 如果timeout=0,取不到鎖時,不等待,直接返回. * @param unit * @return */ public bo

基於SpringBoot AOP面向切面程式設計實現Redis分散式鎖

![](https://img2020.cnblogs.com/other/1815316/202007/1815316-20200708094430273-1467040799.png) **基於SpringBoot AOP面向切面程式設計實現Redis分散式鎖** **基於SpringBoot AOP面

C# Redis分散式鎖(RedLock) - 多節點

Redis單節點的分散式鎖只需要注意三點就可以了: 1.加鎖並設定鎖的過期時間必須是原子操作; 2.鎖的value值必須要有唯一性; 3.釋放鎖的時候要驗證其value值,不是自己加的鎖不能釋放.   但是單節點分散式鎖最大的缺點就是,它只作用在一個Redis節點上,如果該節點掛了,那就掛了. 那可

如何設計redis分散式鎖

文章目錄 分散式鎖的實現有哪些？ 1.Memcached分散式鎖 2.Redis分散式鎖 3.Zookeeper分散式鎖 4.Chubby 如何用Redis實現分散式鎖？ 1.加鎖 2.解鎖

註解形式實現,Redis分散式鎖

Redis工具類參考我的博文:https://blog.csdn.net/weixin_38399962/article/details/82753763 一個註解就可以實現分散式鎖?這麼神奇麼? 首先定義註解: /** * Description:分散式Redis鎖 * User:

分散式鎖, 註解形式, 搞定SpringBoot定時任務@Scheduled 在叢集下的優化

SpringBoot提供了 Schedule模組完美支援定時任務的執行 在實際開發中由於專案部署在分散式或叢集伺服器上 會導致定時任務多次觸發 因此，使用redis分佈鎖機制可以有效避免多次執行定時任務   核心方法是org.springframework.data.redis

redis分散式鎖的實現方式

    前言：分散式鎖的實現方式一般有三種，1：基於資料庫的樂觀鎖。2：基於redis的分散式鎖。3：基於zk的分散式鎖，本文主要介紹第二種實現，由於以前一直是單機寫筆記，所以第一次寫有寫的不好的地方歡迎大家指正。     網上對於redis分散式鎖的實現

Redis實踐 -使用Redis分散式鎖

使用Redis來實現分散式鎖 public class LockTest { private final Jedis jedis; public LockTest() { jedis=new Jedis("localhost",6379); je

redis-分散式鎖的正確實現方式

分散式鎖一般有三種實現方式：1. 資料庫樂觀鎖；2. 基於Redis的分散式鎖；3. 基於ZooKeeper的分散式鎖。本篇部落格將介紹第二種方式，基於Redis實現分散式鎖。雖然網上已經有各種介紹Redis分散式鎖實現的部落格，然而他們的實現卻有著各種各樣的問題，為了避免誤人子弟，本篇部落格將詳細