コミュニティ 学ぶ ツールライブラリ レジャー
検索
日本語
ホームページ > データベース > Redis > 本文

Redis で分散ロックを実装する 5 つの方法のまとめ

WBOY
リリース： 2022-09-14 17:56:47
転載
2446 人が閲覧しました

推奨学習: Redis ビデオ チュートリアル

単一アプリケーションで共有データをロックしないと、データの一貫性の問題が発生します。通常、解決策はそれらをロックすることです。

分散アーキテクチャでは、データ共有操作の問題も発生します。この記事では、Redis を使用して、分散アーキテクチャにおけるデータの一貫性の問題を解決します。

1. 単一マシンのデータ整合性

単一マシンのデータ整合性アーキテクチャを次の図に示します: 複数のクライアントが同じサーバーにアクセスし、同じデータベースに接続できます。

シーンの説明: クライアントは商品の購入プロセスをシミュレートし、Redis の総在庫を 100 のままに設定します。複数のクライアントが同時に購入を行います。 

@RestController
public class IndexController1 {

    @Autowired
    StringRedisTemplate template;

    @RequestMapping("/buy1")
    public String index(){
        // Redis中存有goods:001号商品，数量为100
        String result = template.opsForValue().get("goods:001");
        // 获取到剩余商品数
        int total = result == null ? 0 : Integer.parseInt(result);
        if( total > 0 ){
            // 剩余商品数大于0 ，则进行扣减
            int realTotal = total -1;
            // 将商品数回写数据库
            template.opsForValue().set("goods:001",String.valueOf(realTotal));
            System.out.println("购买商品成功，库存还剩："+realTotal +"件， 服务端口为8001");
            return "购买商品成功，库存还剩："+realTotal +"件， 服务端口为8001";
        }else{
            System.out.println("购买商品失败，服务端口为8001");
        }
        return "购买商品失败，服务端口为8001";
    }
}
ログイン後にコピー

Jmeter を使用して、同時実行性の高いシナリオをシミュレートします。テスト結果は次のとおりです:

テスト結果 複数のユーザーが同じ製品を購入したところ、データの不整合が発生しました。

解決策: 単一アプリケーションの場合は、同時操作に対してロック操作を実行して、データ操作がアトミックであることを確認します。

  • 同期
  • ReentrantLock
@RestController
public class IndexController2 {
// 使用ReentrantLock锁解决单体应用的并发问题
Lock lock = new ReentrantLock();

@Autowired
StringRedisTemplate template;

@RequestMapping("/buy2")
public String index() {

    lock.lock();
    try {
        String result = template.opsForValue().get("goods:001");
        int total = result == null ? 0 : Integer.parseInt(result);
        if (total > 0) {
            int realTotal = total - 1;
            template.opsForValue().set("goods:001", String.valueOf(realTotal));
            System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
            return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
        } else {
            System.out.println("购买商品失败，服务端口为8001");
        }
    } catch (Exception e) {
        lock.unlock();
    } finally {
        lock.unlock();
    }
    return "购买商品失败，服务端口为8001";
}
}
ログイン後にコピー

2. 分散データの一貫性

上記は、単一アプリケーションのデータ一貫性の問題を解決します。ただし、分散アーキテクチャ展開の場合、アーキテクチャは次のようになります。

は 2 つのサービスを提供し、ポートは 8001、8002 で、接続は同じです。 Redis サービス。サービスの前に、ロード バランサーとして Nginx があります。

2 つのサービス コードは、同じですが、ポートが異なります

2 つのサービス 8001 と 8002 を開始します。各サービスは引き続き ReentrantLock でロックされ、# で終了します。 ##Jmeter 同時実行テストにより、データの整合性の問題が発生する可能性があることが判明しました。

3. Redis は分散ロックを実装します

3.1 方法 1

スタンドアロン ロックをキャンセルし、

redis## を使用します# 以下 set分散ロックを実装するコマンドSET KEY VALUE [EX 秒] [PX ミリ秒] [NX|XX]

EX 秒の設定が指定されています有効期限 (秒)
  • PX ミリ秒 指定された有効期限を設定します (ミリ秒)
    • #NX キーが存在しない場合にのみキーを設定します
  • XX のみが設定されますキーが既に存在する場合 
  • @RestController
public class IndexController4 {

    // Redis分布式锁的key
    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate template;

    @RequestMapping("/buy4")
    public String index(){

        // 每个人进来先要进行加锁，key值为"good_lock"，value随机生成
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            // 加锁
            Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value);
            // 加锁失败
            if(!flag){
                return "抢锁失败！";
            }
            System.out.println( value+ " 抢锁成功");
            String result = template.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                int realTotal = total - 1;
                template.opsForValue().set("goods:001", String.valueOf(realTotal));
                // 如果在抢到所之后，删除锁之前，发生了异常，锁就无法被释放，
                // 释放锁操作不能在此操作，要在finally处理
				// template.delete(REDIS_LOCK);
                System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
                return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
            } else {
                System.out.println("购买商品失败，服务端口为8001");
            }
            return "购买商品失败，服务端口为8001";
        }finally {
            // 释放锁
            template.delete(REDIS_LOCK);
        }
    }
}
    ログイン後にコピー
  • 上記のコードは、分散アーキテクチャにおけるデータの一貫性の問題を解決できます。しかし、よく考えてみるとまだまだ問題点があるので、以下で改善していきましょう。
3.2 方法 2 (改善された方法 1)

上記のコードでは、マイクロサービス

jar

パッケージがデプロイされているマシンがプログラムの実行中に突然ハングした場合、コード レベルが

finally コード ブロックにまったく達していません。これは、シャットダウン前にロックが削除されていないことを意味します。この場合、ロックの解除を保証する方法はありませんしたがって必要なものは次のとおりです この key

に有効期限を追加します。

Redis で有効期限を設定するには 2 つの方法があります:

template.expire(REDIS_LOCK,10, TimeUnit.SECONDS)
  • #template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS)
  • 最初の方法 これには別のコード行が必要で、ロックと同じステップに配置されないため、アトミックではなく問題が発生します。
    • 2 番目の方法は有効期限を設定します。問題ありません。ここではこの方法を使用します。

コードを調整し、ロック中に有効期限を設定します。

// 为key加一个过期时间，其余代码不变
Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK,value,10L,TimeUnit.SECONDS);
ログイン後にコピー

この方法は、ロックできない問題を解決します。突然のサービスダウンによりロックが解除される問題。しかし、よく考えてみるとまだまだ問題点があるので、以下で改善していきましょう。

3.3 方法 3 (方法 2 の改良)

方法 2 では、

key

の有効期限を設定します。これにより、

key

が削除できない問題が解決されます。しかし、問題は再びここにあります<p>上面设置了<code>key的过期时间为10秒，如果业务逻辑比较复杂，需要调用其他微服务，处理时间需要15秒（模拟场

景，别较真），而当10秒钟过去之后，这个key就过期了，其他请求就又可以设置这个key，此时如果耗时15秒

的请求处理完了，回来继续执行程序，就会把别人设置的key给删除了，这是个很严重的问题！

所以，谁上的锁，谁才能删除

@RestController
public class IndexController6 {

    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate template;

    @RequestMapping("/buy6")
    public String index(){

        // 每个人进来先要进行加锁，key值为"good_lock"
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            // 为key加一个过期时间
            Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);

            // 加锁失败
            if(!flag){
                return "抢锁失败！";
            }
            System.out.println( value+ " 抢锁成功");
            String result = template.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                // 如果在此处需要调用其他微服务，处理时间较长。。。
                int realTotal = total - 1;
                template.opsForValue().set("goods:001", String.valueOf(realTotal));
                System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
                return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
            } else {
                System.out.println("购买商品失败，服务端口为8001");
            }
            return "购买商品失败，服务端口为8001";
        }finally {
            // 谁加的锁，谁才能删除！！！！
            if(template.opsForValue().get(REDIS_LOCK).equals(value)){
                template.delete(REDIS_LOCK);
            }
        }
    }
}
ログイン後にコピー

这种方式解决了因服务处理时间太长而释放了别人锁的问题。这样就没问题了吗？

3.4 方式四（改进方式三）

在上面方式三下，规定了谁上的锁，谁才能删除，但finally快的判断和del删除操作不是原子操作，并发的时候也会出问题，并发嘛，就是要保证数据的一致性，保证数据的一致性，最好要保证对数据的操作具有原子性。

在Redis的set命令介绍中，最后推荐Lua脚本进行锁的删除，地址

@RestController
public class IndexController7 {

    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate template;

    @RequestMapping("/buy7")
    public String index(){

        // 每个人进来先要进行加锁，key值为"good_lock"
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            // 为key加一个过期时间
            Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);
            // 加锁失败
            if(!flag){
                return "抢锁失败！";
            }
            System.out.println( value+ " 抢锁成功");
            String result = template.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                // 如果在此处需要调用其他微服务，处理时间较长。。。
                int realTotal = total - 1;
                template.opsForValue().set("goods:001", String.valueOf(realTotal));
                System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
                return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
            } else {
                System.out.println("购买商品失败，服务端口为8001");
            }
            return "购买商品失败，服务端口为8001";
        }finally {
            // 谁加的锁，谁才能删除，使用Lua脚本，进行锁的删除

            Jedis jedis = null;
            try{
                jedis = RedisUtils.getJedis();

                String script = "if redis.call(&#39;get&#39;,KEYS[1]) == ARGV[1] " +
                        "then " +
                        "return redis.call(&#39;del&#39;,KEYS[1]) " +
                        "else " +
                        "   return 0 " +
                        "end";

                Object eval = jedis.eval(script, Collections.singletonList(REDIS_LOCK), Collections.singletonList(value));
                if("1".equals(eval.toString())){
                    System.out.println("-----del redis lock ok....");
                }else{
                    System.out.println("-----del redis lock error ....");
                }
            }catch (Exception e){

            }finally {
                if(null != jedis){
                    jedis.close();
                }
            }
        }
    }
}
ログイン後にコピー

3.5 方式五（改进方式四）

在方式四下，规定了谁上的锁，谁才能删除，并且解决了删除操作没有原子性问题。但还没有考虑缓存续命，以及Redis集群部署下，异步复制造成的锁丢失：主节点没来得及把刚刚set进来这条数据给从节点，就挂了。所以直接上RedLock的Redisson落地实现。

@RestController
public class IndexController8 {

    public static final String REDIS_LOCK = "good_lock";

    @Autowired
    StringRedisTemplate template;

    @Autowired
    Redisson redisson;

    @RequestMapping("/buy8")
    public String index(){

        RLock lock = redisson.getLock(REDIS_LOCK);
        lock.lock();

        // 每个人进来先要进行加锁，key值为"good_lock"
        String value = UUID.randomUUID().toString().replace("-","");
        try{
            String result = template.opsForValue().get("goods:001");
            int total = result == null ? 0 : Integer.parseInt(result);
            if (total > 0) {
                // 如果在此处需要调用其他微服务，处理时间较长。。。
                int realTotal = total - 1;
                template.opsForValue().set("goods:001", String.valueOf(realTotal));
                System.out.println("购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001");
                return "购买商品成功，库存还剩：" + realTotal + "件， 服务端口为8001";
            } else {
                System.out.println("购买商品失败，服务端口为8001");
            }
            return "购买商品失败，服务端口为8001";
        }finally {
            if(lock.isLocked() && lock.isHeldByCurrentThread()){
                lock.unlock();
            }
        }
    }
}
ログイン後にコピー

推荐学习：Redis视频教程

以上がRedis で分散ロックを実装する 5 つの方法のまとめの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。

関連ラベル：
redis
ソース：jb51.net
前の記事：Redis が遅い理由とそのトラブルシューティング方法についての簡単な説明 次の記事：Redis ソースコード設計解析のイベント処理を理解するための 1 つの記事
このウェブサイトの声明
この記事の内容はネチズンが自主的に寄稿したものであり、著作権は原著者に帰属します。このサイトは、それに相当する法的責任を負いません。盗作または侵害の疑いのあるコンテンツを見つけた場合は、admin@php.cn までご連絡ください。
著者別の最新記事
最新の問題
Symfony Redis は、env ファイルで定義されたホスト (デフォルトは localhost) に接続できません キャッシュメカニズムとして Redis を使用した新しい Symfony セットアップがあります。デフォルトのローカルホストではなく、特定のホストに接続したいと考えています。運用環...
から 2024-04-06 10:53:02
0
1
375
関連トピック
詳細>
人気のおすすめ
人気のチュートリアル
詳細>
関連するチュートリアル
人気のおすすめ
最新のコース
最新のダウンロード
詳細>
ウェブエフェクト
公式サイト
サイト素材
フロントエンドテンプレート