分散ロックには Redis または Zookeeper を使用する必要がありますか?

分散ロックは通常、次の方法で実装されます:

• データベース
• キャッシュ (例: Redis)
• Zookeeper
• etcd

#実際 開発では Redis と Zookeeper が最も一般的に使用されるため、この記事ではこれら 2 つについてのみ説明します。

この問題について説明する前に、まずビジネス シナリオを見てみましょう:

システム A は電子商取引システムです。現在、マシン上に展開されています。ユーザーがいます。ただし、ユーザーは注文する前に在庫を確認して、在庫が十分であることを確認してから注文する必要があります。

システムにはある程度の同時実行性があるため、あらかじめ商品の在庫が Redis に保存されており、ユーザーが注文すると、## の在庫が生成されます。 #Redis が更新されます。

現時点でのシステム アーキテクチャは次のとおりです。

しかし、これでは

問題が発生します: ある瞬間、ある商品の在庫は1です。このとき同時に2つのリクエストが来ます。一方のリクエストは上図のステップ3まで実行され、データベースの在庫は0に更新されますが、ステップ4まだ実行されていません。

もう一方のリクエストはステップ 2 に到達し、在庫がまだ 1 であることが判明したため、ステップ 3 に進みます。

結果として商品は2個売れていますが、実際には在庫は1個しかありません。

明らかに何かが間違っています。これは典型的な在庫過剰問題です。

この時点で、解決策は簡単に思いつきます。ロックを使用してステップ 2、3、4 をロックし、完了後に別のスレッドが入ることができるようにします。ステップ2.のステップを実行します。

上図より、手順2の実行時にJavaが提供するsynchronizedLockまたはReentrantLockを利用してロックし、手順4の実行後にロックを解除します。

このように、3 つのステップ 2、3、および 4 は「ロック」され、複数のスレッドはシリアルにのみ実行できます。

しかし、良い時代は長くは続かず、システム全体の同時実行性が急増し、1 台のマシンでは処理できなくなりました。ここで、以下に示すようにマシンを追加する必要があります。

マシンを追加すると、システムは上の図のようになります。

2 人のユーザーからのリクエストが同時に到着し、異なるマシンに送信されると仮定します。これら 2 つのリクエストは同時に実行できますか。そうしないと、在庫の売れすぎの問題が発生します。 ＃＃＃＃＃＃なぜ？上の図の 2 つの A システムは 2 つの異なる JVM で実行されているため、追加されるロックはそれぞれの JVM 内のスレッドに対してのみ有効であり、他の JVM 内のスレッドに対しては無効です。

したがって、ここでの問題は次のとおりです。Java によって提供されるネイティブ ロック メカニズムは、複数マシンのデプロイメント シナリオでは失敗します。

これは、2 つのマシンによって追加されたロックが同じロックではないためです (異なる JVM に 2 つのロックが存在します)。

では、2 台のマシンによって追加されたロックが同じであることを確認すれば、問題は解決するのではないでしょうか?

この時点で、分散ロックが堂々と登場するときが来ました。分散ロックのアイデアは次のとおりです:

グローバルでユニークな

取得方法を提供するシステム全体の「モノ」をロックし、各システムがロックする必要がある場合、この「モノ」にロックの取得を要求するため、異なるシステムがそれを同じロックであると見なすことができます。 この「もの」としては、Redis、Zookeeper、データベースなどがあります。

テキストの説明はあまり直観的ではありません。下の図を見てみましょう:

上記の分析を通じて、在庫が売れすぎているシナリオが機能することがわかりました。分散デプロイメント システム この場合、Java のネイティブ ロック メカニズムを使用してもスレッドの安全性を保証できないため、分散ロック ソリューションを使用する必要があります。

それでは、分散ロックを実装するにはどうすればよいでしょうか?それでは続きを読んでください！

Redis に基づく分散ロックの実装 上記は分散ロックを使用する必要がある理由を分析したものです。ここで説明します。具体的には、実装時に分散ロックをどのように処理するかに注目してください。

最も一般的な解決策は、分散ロックに Redis を使用することです。

分散ロックに Redis を使用するというアイデアは、大まかに次のとおりです。ロックが追加されたことを示す値を Redis に設定し、ロックが解放されたときにキーを削除します。

具体的なコードは次のとおりです:

// 获取锁
// 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 キーを使用してください。 value NX PX ミリ秒コマンド

  使用しない場合は、最初に値を設定してから有効期限を設定します。これはアトミックな操作ではないため、有効期限を設定する前にクラッシュする可能性があり、デッドロックが発生します (キーが存在します)。永続的に)

• 値は一意である必要があります

  #これは、ロックを解除するときに、値がロックされた値と一致していることを確認する必要があるためです。キーを削除する前の値。

  これは状況を回避します: A がロックを取得し、有効期限が 30 秒であるとします。35 秒後、ロックは自動的に解放されます。A はロックを解放しようとしますが、この時点で B がロックを取得する可能性があります。クライアント A は B のロックを削除できません。

クライアントが分散ロックを実装する方法を検討することに加えて、redis のデプロイメントも考慮する必要があります。

Redis には 3 つのデプロイ方法があります:

• 単一マシン モード
• マスター/スレーブ センチネル選出モード
• redis クラスター モード

分散ロックに Redis を使用するデメリットは、スタンドアロン デプロイメント モードを使用すると、単一点の問題が発生することです。 、redis が失敗する限り。ロックしても機能しません。

マスタースレーブモードを採用 ロック時は1ノードのみロック センチネルによる高可用性を実現しても、マスターノードに障害が発生しマスタースレーブ切り替えが発生した場合、ロストロックが発生する可能性があります問題。

上記の考察に基づいて、実際、redis の作者もこの問題を検討し、RedLock アルゴリズムを提案しました。このアルゴリズムの意味は、おおよそ次のとおりです:

デプロイメントが次のようになっていると仮定します。 Redis のモードは Redis クラスターに合計 5 つのマスター ノードがあります。次の手順でロックを取得します:

• 获取当前时间戳，单位是毫秒
• 轮流尝试在每个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 には次の 4 つのイベントがあります:

• 
  
ノード作成
• #ノードの削除
• ノード データの変更
• 子ノードの変更
• zk の上記の特性に基づいて、zk を使用して分散ロックを実装する実装計画を簡単に思いつくことができます。

zk の一時ノードと順序付けされたノードをそれぞれ使用します。スレッドは、/lock/ ディレクトリなどの zk に一時的に順序付けされたノードを作成することによってロックを取得します。

1. ノードの作成に成功したら、/lock ディレクトリ内のすべての一時ノードを取得し、現在のスレッドによって作成されたノードが、

2. #現在のスレッドによって作成されたノードが、すべてのノードの中で最も小さいシーケンス番号を持つノードである場合、ロックの取得は成功したと考えられます。

3. #現在のスレッドによって作成されたノードが、すべてのノードの中で最もシリアル番号が小さいノードではない場合は、ノードの前にイベント リスナーをノードに追加します。シリアルナンバー。

   比如当前线程获取到的节点序号为/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的开源客户端的基本使用，简要的介绍了其实现原理。

2 つのスキームの長所と短所の比較

2 つの分散ロック実装スキームを学習した後、このセクションでは次のことを行う必要があります。 redis と zk の実装ソリューションのそれぞれの長所と短所について説明します。

redis の分散ロックについては、次のような欠点があります:

• ロックの取得方法が単純かつ粗雑であり、ロックが取得できない場合は、ロックの取得を試行し続けるため、消費パフォーマンスを比較します。
• さらに、redis の設計上の位置付けにより、データの一貫性が強くないと判断され、極端な場合には問題が発生する可能性があります。ロック モデルは十分に堅牢ではありません
• レッドロック アルゴリズムを使用して実装したとしても、一部の複雑なシナリオでは、その実装が 100% 問題なく行われるという保証はありません。 redlock の詳細については、「分散ロックの実行方法」を参照してください。
• redis 分散ロックでは、実際には常にロックの取得を試行する必要があり、パフォーマンスが消費されます。

しかし一方で、分散ロックを実装するために Redis を使用することは多くの企業で非常に一般的であり、ほとんどの場合、いわゆる「非常に複雑なシナリオ」に遭遇することはありません

したがって、分散ロックとして redis を使用することも良い解決策です. 最も重要な点は、redis が高いパフォーマンスを持ち、高同時実行ロックの取得および解放操作をサポートできることです。

zk 分散ロックの場合:

• zookeeper の自然な設計上の位置付けは、分散調整と強力な一貫性です。ロック モデルは堅牢で使いやすく、分散ロックに適しています。
• ロックが取得できない場合は、リスナーを追加するだけで済み、常にポーリングを行う必要がなく、パフォーマンスの消費も小さいです。

しかし、zk には欠点もあります。ロックの申請とロックの解放を頻繁に行うクライアントが増えると、zk クラスターへの負荷が大きくなります。

要約:

要約すると、redis と Zookeeper にはそれぞれ長所と短所があります。これらの問題は、テクノロジーを選択する際の参考要素として使用できます。

以上が分散ロックには Redis または Zookeeper を使用する必要がありますか?の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。