分散式鎖用 Redis 還是 Zookeeper？-java教程-PHP中文網

分散式鎖定的實作方式通常有：

資料庫
##快取（例如：
Redis）
Zookeeper
etcd

在討論這個問題之前，我們先來看一個業務場景：

系統A是一個電商系統，目前是一台機器部署，系統中有一個用戶下訂單的接口，但是用戶下訂單前一定要去檢查庫存，確保庫存足夠了才會給用戶下單。

由於系統有一定的並發，所以會預先將商品的庫存保存在

Redis

中，用戶下單的時候會更新Redis的庫存。此時系統架構如下：

產生一個問題

：假如某個時刻，redis裡面的某個商品庫存為1，此時兩個請求同時到來，其中一個請求執行到上圖的第3步，更新資料庫的庫存為0，但是第4步還沒有執行。而另一個請求執行到了第2步，發現庫存還是1，就繼續執行第3步。

這樣的結果，是導致賣出了2個商品，然而其實庫存只有1個。

很明顯不對啊！這就是典型的庫存超賣問題

此時，我們很容易想到解決方案：用鎖把2、3、4步鎖住，讓他們執行完之後，另一個線程才能進來執行第2步。

依照上面的圖，執行步驟2時，使用Java提供的synchronized或ReentrantLock來鎖住，然後在第4步執行完後才釋放鎖定。

這樣一來，2、3、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做分散式鎖定的缺點在於：如果採用單機部署模式，就會有單點問題，只要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(&#39;exists&#39;, KEYS[1]) == 0) then " +
                  "redis.call(&#39;hset&#39;, KEYS[1], ARGV[2], 1); " +
                  "redis.call(&#39;pexpire&#39;, KEYS[1], ARGV[1]); " +
                  "return nil; " +
              "end; " +
              "if (redis.call(&#39;hexists&#39;, KEYS[1], ARGV[2]) == 1) then " +
                  "redis.call(&#39;hincrby&#39;, KEYS[1], ARGV[2], 1); " +
                  "redis.call(&#39;pexpire&#39;, KEYS[1], ARGV[1]); " +
                  "return nil; " +
              "end; " +
              "return redis.call(&#39;pttl&#39;, 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&#39;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();

登入後複製

小结：

本节分析了使用Redis作为分布式锁的具体落地方案，以及其一些局限性，然后介绍了一个Redis的客户端框架redisson。这也是我推荐大家使用的，比自己写代码实现会少care很多细节。

基于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實現分散式鎖的落地方案：
######在建立節點成功後，取得/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分散式鎖定而言: