面試不懂分佈式鎖？那得多吃虧。。。
做者：jianfengnode
本文來自讀者的投稿redis
------------------------------------算法
爲何用分佈式鎖？
在討論這個問題以前，咱們先來看一個業務場景：數據庫
系統A是一個電商系統，目前是一臺機器部署，系統中有一個用戶下訂單的接口，可是用戶下訂單以前必定要去檢查一下庫存，確保庫存足夠了纔會給用戶下單。api
因爲系統有必定的併發，因此會預先將商品的庫存保存在redis中，用戶下單的時候會更新redis的庫存。安全
此時系統架構以下：bash
可是這樣一來會產生一個問題：假如某個時刻，redis裏面的某個商品庫存爲1，此時兩個請求同時到來，其中一個請求執行到上圖的第3步，更新數據庫的庫存爲0，可是第4步尚未執行。微信
而另一個請求執行到了第2步，發現庫存仍是1，就繼續執行第3步。架構
這樣的結果，是致使賣出了2個商品，然而其實庫存只有1個。併發
很明顯不對啊！這就是典型的庫存超賣問題
此時，咱們很容易想到解決方案：用鎖把二、三、4步鎖住，讓他們執行完以後，另外一個線程才能進來執行第2步。
按照上面的圖，在執行第2步時，使用Java提供的synchronized或者ReentrantLock來鎖住，而後在第4步執行完以後才釋放鎖。
這樣一來，二、三、4 這3個步驟就被「鎖」住了，多個線程之間只能串行化執行。
可是好景不長，整個系統的併發飆升，一臺機器扛不住了。如今要增長一臺機器，以下圖：
增長機器以後，系統變成上圖所示，個人天！
假設此時兩個用戶的請求同時到來，可是落在了不一樣的機器上，那麼這兩個請求是能夠同時執行了，仍是會出現庫存超賣的問題。
爲何呢？由於上圖中的兩個A系統，運行在兩個不一樣的JVM裏面，他們加的鎖只對屬於本身JVM裏面的線程有效，對於其餘JVM的線程是無效的。
所以，這裏的問題是：Java提供的原生鎖機制在多機部署場景下失效了
這是由於兩臺機器加的鎖不是同一個鎖(兩個鎖在不一樣的JVM裏面)。
那麼，咱們只要保證兩臺機器加的鎖是同一個鎖，問題不就解決了嗎？
此時，就該分佈式鎖隆重登場了，分佈式鎖的思路是：
在整個系統提供一個全局、惟一的獲取鎖的「東西」，而後每一個系統在須要加鎖時，都去問這個「東西」拿到一把鎖，這樣不一樣的系統拿到的就能夠認爲是同一把鎖。
至於這個「東西」，能夠是Redis、Zookeeper，也能夠是數據庫。
文字描述不太直觀，咱們來看下圖：
經過上面的分析，咱們知道了庫存超賣場景在分佈式部署系統的狀況下使用Java原生的鎖機制沒法保證線程安全，因此咱們須要用到分佈式鎖的方案。
那麼，如何實現分佈式鎖呢？接着往下看！
基於Redis實現分佈式鎖
上面分析爲啥要使用分佈式鎖了，這裏咱們來具體看看分佈式鎖落地的時候應該怎麼樣處理。
最多見的一種方案就是使用Redis作分佈式鎖
使用Redis作分佈式鎖的思路大概是這樣的：在redis中設置一個值表示加了鎖，而後釋放鎖的時候就把這個key刪除。
具體代碼是這樣的：
// 獲取鎖
// NX是指若是key不存在就成功，key存在返回false，PX能夠指定過時時間
SET anyLock unique_value NX PX 30000
// 釋放鎖：經過執行一段lua腳本
// 釋放鎖涉及到兩條指令，這兩條指令不是原子性的
// 須要用到redis的lua腳本支持特性，redis執行lua腳本是原子性的
if redis.call("get",KEYS[1]) == ARGV[1] then
return redis.call("del",KEYS[1])
else
return 0
end複製代碼
這種方式有幾大要點：
必定要用SET key value NX PX milliseconds 命令
若是不用，先設置了值，再設置過時時間，這個不是原子性操做，有可能在設置過時時間以前宕機，會形成死鎖(key永久存在)
value要具備惟一性
這個是爲了在解鎖的時候，須要驗證value是和加鎖的一致才刪除key。
這是避免了一種狀況：假設A獲取了鎖，過時時間30s，此時35s以後，鎖已經自動釋放了，A去釋放鎖，可是此時可能B獲取了鎖。A客戶端就不能刪除B的鎖了。
除了要考慮客戶端要怎麼實現分佈式鎖以外，還須要考慮redis的部署問題。
redis有3種部署方式：
單機模式
master-slave + sentinel選舉模式
redis cluster模式
使用redis作分佈式鎖的缺點在於：若是採用單機部署模式，會存在單點問題，只要redis故障了。加鎖就不行了。
採用master-slave模式，加鎖的時候只對一個節點加鎖，即使經過sentinel作了高可用，可是若是master節點故障了，發生主從切換，此時就會有可能出現鎖丟失的問題。
基於以上的考慮，其實redis的做者也考慮到這個問題，他提出了一個RedLock的算法，這個算法的意思大概是這樣的：
假設redis的部署模式是redis cluster，總共有5個master節點，經過如下步驟獲取一把鎖：
獲取當前時間戳，單位是毫秒
輪流嘗試在每一個master節點上建立鎖，過時時間設置較短，通常就幾十毫秒
嘗試在大多數節點上創建一個鎖，好比5個節點就要求是3個節點（n / 2 +1）
客戶端計算創建好鎖的時間，若是創建鎖的時間小於超時時間，就算創建成功了
要是鎖創建失敗了，那麼就依次刪除這個鎖
只要別人創建了一把分佈式鎖，你就得不斷輪詢去嘗試獲取鎖
可是這樣的這種算法仍是頗具爭議的，可能還會存在很多的問題，沒法保證加鎖的過程必定正確。
另外一種方式：Redisson
此外，實現Redis的分佈式鎖，除了本身基於redis client原生api來實現以外，還可使用開源框架：Redission
Redisson是一個企業級的開源Redis Client，也提供了分佈式鎖的支持。我也很是推薦你們使用，爲何呢？
回想一下上面說的，若是本身寫代碼來經過redis設置一個值，是經過下面這個命令設置的。
SET anyLock unique_value NX PX 30000
這裏設置的超時時間是30s，假如我超過30s都尚未完成業務邏輯的狀況下，key會過時，其餘線程有可能會獲取到鎖。
這樣一來的話，第一個線程還沒執行完業務邏輯，第二個線程進來了也會出現線程安全問題。因此咱們還須要額外的去維護這個過時時間，太麻煩了~
咱們來看看redisson是怎麼實現的？先感覺一下使用redission的爽：
Config config = new Config();
config.useClusterServers()
.addNodeAddress("redis://192.168.31.101:7001")
.addNodeAddress("redis://192.168.31.101:7002")
.addNodeAddress("redis://192.168.31.101:7003")
.addNodeAddress("redis://192.168.31.102:7001")
.addNodeAddress("redis://192.168.31.102:7002")
.addNodeAddress("redis://192.168.31.102:7003");
RedissonClient redisson = Redisson.create(config);
RLock lock = redisson.getLock("anyLock");
lock.lock();
lock.unlock();複製代碼
就是這麼簡單，咱們只須要經過它的api中的lock和unlock便可完成分佈式鎖，他幫咱們考慮了不少細節：
redisson全部指令都經過lua腳本執行，redis支持lua腳本原子性執行
redisson設置一個key的默認過時時間爲30s,若是某個客戶端持有一個鎖超過了30s怎麼辦？
redisson中有一個
watchdog的概念，翻譯過來就是看門狗，它會在你獲取鎖以後，每隔10秒幫你把key的超時時間設爲30s這樣的話，就算一直持有鎖也不會出現key過時了，其餘線程獲取到鎖的問題了。
redisson的「看門狗」邏輯保證了沒有死鎖發生。
(若是機器宕機了，看門狗也就沒了。此時就不會延長key的過時時間，到了30s以後就會自動過時了，其餘線程能夠獲取到鎖)
這裏稍微貼出來其實現代碼：
// 加鎖邏輯
private <T> RFuture<Long> tryAcquireAsync(long leaseTime, TimeUnit unit, final long threadId) {
if (leaseTime != -1) {
return tryLockInnerAsync(leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
}
// 調用一段lua腳本，設置一些key、過時時間
RFuture<Long> ttlRemainingFuture = tryLockInnerAsync(commandExecutor.getConnectionManager().getCfg().getLockWatchdogTimeout(), TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
ttlRemainingFuture.addListener(new FutureListener<Long>() {
@Override
public void operationComplete(Future<Long> future) throws Exception {
if (!future.isSuccess()) {
return;
}
Long ttlRemaining = future.getNow();
// lock acquired
if (ttlRemaining == null) {
// 看門狗邏輯
scheduleExpirationRenewal(threadId);
}
}
});
return ttlRemainingFuture;
}
<T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
internalLockLeaseTime = unit.toMillis(leaseTime);
return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
"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; " +
"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; " +
"return redis.call('pttl', KEYS[1]);",
Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
}
// 看門狗最終會調用了這裏
private void scheduleExpirationRenewal(final long threadId) {
if (expirationRenewalMap.containsKey(getEntryName())) {
return;
}
// 這個任務會延遲10s執行
Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
@Override
public void run(Timeout timeout) throws Exception {
// 這個操做會將key的過時時間從新設置爲30s
RFuture<Boolean> future = renewExpirationAsync(threadId);
future.addListener(new FutureListener<Boolean>() {
@Override
public void operationComplete(Future<Boolean> future) throws Exception {
expirationRenewalMap.remove(getEntryName());
if (!future.isSuccess()) {
log.error("Can't update lock " + getName() + " expiration", future.cause());
return;
}
if (future.getNow()) {
// reschedule itself
// 經過遞歸調用本方法，無限循環延長過時時間
scheduleExpirationRenewal(threadId);
}
}
});
}
}, internalLockLeaseTime / 3, TimeUnit.MILLISECONDS);
if (expirationRenewalMap.putIfAbsent(getEntryName(), new ExpirationEntry(threadId, task)) != null) {
task.cancel();
}
}複製代碼
另外，redisson還提供了對redlock算法的支持,它的用法也很簡單：
RedissonClient redisson = Redisson.create(config);
RLock lock1 = redisson.getFairLock("lock1");
RLock lock2 = redisson.getFairLock("lock2");
RLock lock3 = redisson.getFairLock("lock3");
RedissonRedLock multiLock = new RedissonRedLock(lock1, lock2, lock3);
multiLock.lock();
multiLock.unlock();複製代碼
基於zookeeper實現分佈式鎖
常見的分佈式鎖實現方案裏面，除了使用redis來實現以外，使用zookeeper也能夠實現分佈式鎖。
在介紹zookeeper(下文用zk代替)實現分佈式鎖的機制以前，先粗略介紹一下zk是什麼東西：
Zookeeper是一種提供配置管理、分佈式協同以及命名的中心化服務。
zk的模型是這樣的：zk包含一系列的節點，叫作znode，就好像文件系統同樣每一個znode表示一個目錄，而後znode有一些特性：
有序節點：假如當前有一個父節點爲
/lock，咱們能夠在這個父節點下面建立子節點；zookeeper提供了一個可選的有序特性，例如咱們能夠建立子節點「/lock/node-」而且指明有序，那麼zookeeper在生成子節點時會根據當前的子節點數量自動添加整數序號
也就是說，若是是第一個建立的子節點，那麼生成的子節點爲
/lock/node-0000000000，下一個節點則爲/lock/node-0000000001，依次類推。臨時節點：客戶端能夠創建一個臨時節點，在會話結束或者會話超時後，zookeeper會自動刪除該節點。
事件監聽：在讀取數據時，咱們能夠同時對節點設置事件監聽，當節點數據或結構變化時，zookeeper會通知客戶端。當前zookeeper有以下四種事件：
節點建立
節點刪除
節點數據修改
子節點變動
基於以上的一些zk的特性，咱們很容易得出使用zk實現分佈式鎖的落地方案：
使用zk的臨時節點和有序節點，每一個線程獲取鎖就是在zk建立一個臨時有序的節點，好比在/lock/目錄下。
建立節點成功後，獲取/lock目錄下的全部臨時節點，再判斷當前線程建立的節點是不是全部的節點的序號最小的節點
若是當前線程建立的節點是全部節點序號最小的節點，則認爲獲取鎖成功。
若是當前線程建立的節點不是全部節點序號最小的節點，則對節點序號的前一個節點添加一個事件監聽。
好比當前線程獲取到的節點序號爲
/lock/003,而後全部的節點列表爲[/lock/001,/lock/002,/lock/003],則對/lock/002這個節點添加一個事件監聽器。
若是鎖釋放了，會喚醒下一個序號的節點，而後從新執行第3步，判斷是否本身的節點序號是最小。
好比/lock/001釋放了，/lock/002監聽到時間，此時節點集合爲[/lock/002,/lock/003],則/lock/002爲最小序號節點，獲取到鎖。
整個過程以下：
具體的實現思路就是這樣，至於代碼怎麼寫，這裏比較複雜就不貼出來了。
Curator介紹
Curator是一個zookeeper的開源客戶端，也提供了分佈式鎖的實現。
他的使用方式也比較簡單：
InterProcessMutex interProcessMutex = new InterProcessMutex(client,"/anyLock");
interProcessMutex.acquire();
interProcessMutex.release();複製代碼
其實現分佈式鎖的核心源碼以下：
private boolean internalLockLoop(long startMillis, Long millisToWait, String ourPath) throws Exception
{
boolean haveTheLock = false;
boolean doDelete = false;
try {
if ( revocable.get() != null ) {
client.getData().usingWatcher(revocableWatcher).forPath(ourPath);
}
while ( (client.getState() == CuratorFrameworkState.STARTED) && !haveTheLock ) {
// 獲取當前全部節點排序後的集合
List<String> children = getSortedChildren();
// 獲取當前節點的名稱
String sequenceNodeName = ourPath.substring(basePath.length() + 1); // +1 to include the slash
// 判斷當前節點是不是最小的節點
PredicateResults predicateResults = driver.getsTheLock(client, children, sequenceNodeName, maxLeases);
if ( predicateResults.getsTheLock() ) {
// 獲取到鎖
haveTheLock = true;
} else {
// 沒獲取到鎖，對當前節點的上一個節點註冊一個監聽器
String previousSequencePath = basePath + "/" + predicateResults.getPathToWatch();
synchronized(this){
Stat stat = client.checkExists().usingWatcher(watcher).forPath(previousSequencePath);
if ( stat != null ){
if ( millisToWait != null ){
millisToWait -= (System.currentTimeMillis() - startMillis);
startMillis = System.currentTimeMillis();
if ( millisToWait <= 0 ){
doDelete = true; // timed out - delete our node
break;
}
wait(millisToWait);
}else{
wait();
}
}
}
// else it may have been deleted (i.e. lock released). Try to acquire again
}
}
}
catch ( Exception e ) {
doDelete = true;
throw e;
} finally{
if ( doDelete ){
deleteOurPath(ourPath);
}
}
return haveTheLock;
}複製代碼
其實curator實現分佈式鎖的底層原理和上面分析的是差很少的。這裏咱們用一張圖詳細描述其原理：
小結：
本節介紹了zookeeperr實現分佈式鎖的方案以及zk的開源客戶端的基本使用，簡要的介紹了其實現原理。
兩種方案的優缺點比較
學完了兩種分佈式鎖的實現方案以後，本節須要討論的是redis和zk的實現方案中各自的優缺點。
對於redis的分佈式鎖而言，它有如下缺點：
它獲取鎖的方式簡單粗暴，獲取不到鎖直接不斷嘗試獲取鎖，比較消耗性能。
另外來講的話，redis的設計定位決定了它的數據並非強一致性的，在某些極端狀況下，可能會出現問題。鎖的模型不夠健壯
即使使用redlock算法來實現，在某些複雜場景下，也沒法保證其實現100%沒有問題，關於redlock的討論能夠看How to do distributed locking
redis分佈式鎖，其實須要本身不斷去嘗試獲取鎖，比較消耗性能。
可是另外一方面使用redis實現分佈式鎖在不少企業中很是常見，並且大部分狀況下都不會遇到所謂的「極端複雜場景」
因此使用redis做爲分佈式鎖也不失爲一種好的方案，最重要的一點是redis的性能很高，能夠支撐高併發的獲取、釋放鎖操做。
對於zk分佈式鎖而言:
zookeeper天生設計定位就是分佈式協調，強一致性。鎖的模型健壯、簡單易用、適合作分佈式鎖。
若是獲取不到鎖，只須要添加一個監聽器就能夠了，不用一直輪詢，性能消耗較小。
可是zk也有其缺點：若是有較多的客戶端頻繁的申請加鎖、釋放鎖，對於zk集羣的壓力會比較大。
小結：
綜上所述，redis和zookeeper都有其優缺點。咱們在作技術選型的時候能夠根據這些問題做爲參考因素。
做者的一些建議
經過前面的分析，實現分佈式鎖的兩種常見方案：redis和zookeeper，他們各有千秋。應該如何選型呢？
就我的而言的話，我比較推崇zk實現的鎖：
由於redis是有可能存在隱患的，可能會致使數據不對的狀況。可是，怎麼選用要看具體在公司的場景了。
若是公司裏面有zk集羣條件，優先選用zk實現，可是若是說公司裏面只有redis集羣，沒有條件搭建zk集羣。
那麼其實用redis來實現也能夠，另外還多是系統設計者考慮到了系統已經有redis，可是又不但願再次引入一些外部依賴的狀況下，能夠選用redis。
這個是要系統設計者基於架構的考慮了
END
推薦一個專欄：
《從零開始帶你成爲JVM實戰高手》
做者是我多年好友，之前團隊的左膀右臂
一塊兒經歷過各類大型複雜系統上線的血雨腥風
現任阿里資深技術專家，對JVM有豐富的生產實踐經驗
專欄目錄參見文末，能夠掃下方海報進行試讀
經過上面海報購買，再返你24元
領取方式：加微信號：Giotto1245，暗號：返現
- 1. 面試不懂分佈式鎖？那得多吃虧。。。
- 2. 不懂Spring的9種設計模式，面試會吃虧的
- 3. AI崗位面試抓不住重點，究竟有多吃虧？
- 4. 分佈式鎖那點事
- 5. 輕鬆搞懂鎖和分佈式鎖
- 6. redis分佈式鎖實現-面試題
- 7. 分佈式鎖的實現面試題
- 8. redis的分佈式鎖（面試題）
- 9. 面試：你懂什麼是分佈式系統嗎？Redis分佈式鎖都不會？
- 10. 面試官三連問：分佈式鎖你知道多少？
- 更多相關文章...
- • ASP.NET Web Pages - 頁面佈局 - ASP.NET 教程
- • Redis發佈訂閱模式 - Redis教程
- • 再有人問你分佈式事務，把這篇扔給他
- • 常用的分佈式事務解決方案
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 面試不懂分佈式鎖？那得多吃虧。。。
- 2. 不懂Spring的9種設計模式，面試會吃虧的
- 3. AI崗位面試抓不住重點，究竟有多吃虧？
- 4. 分佈式鎖那點事
- 5. 輕鬆搞懂鎖和分佈式鎖
- 6. redis分佈式鎖實現-面試題
- 7. 分佈式鎖的實現面試題
- 8. redis的分佈式鎖（面試題）
- 9. 面試：你懂什麼是分佈式系統嗎？Redis分佈式鎖都不會？
- 10. 面試官三連問：分佈式鎖你知道多少？