suchen

Heim  >  Artikel  >  Datenbank  >  Zusammenfassung von fünf Möglichkeiten zur Implementierung verteilter Sperren in Redis

Zusammenfassung von fünf Möglichkeiten zur Implementierung verteilter Sperren in Redis

WBOY
WBOYnach vorne
2022-09-14 17:56:472451Durchsuche

Empfohlenes Lernen: Redis-Video-Tutorial

Wenn wir in einer einzelnen Anwendung die gemeinsam genutzten Daten nicht sperren, treten normalerweise Datenkonsistenzprobleme auf. Unsere Lösung besteht darin, sie zu sperren.

In der verteilten Architektur werden wir auch auf Probleme beim Datenaustausch stoßen. In diesem Artikel wird Redis verwendet, um das Datenkonsistenzproblem in der verteilten Architektur zu lösen. 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模拟高并发场景，测试结果如下：

测试结果出现多个用户购买同一商品，发生了数据不一致问题！

解决办法：单体应用的情况下，对并发的操作进行加锁操作，保证对数据的操作具有原子性

  • synchronized
  • 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. 分布式数据一致性

上面解决了单体应用的数据一致性问题，但如果是分布式架构部署呢，架构如下：

提供两个服务，端口分别为8001、8002，连接同一个Redis服务，在服务前面有一台Nginx作为负载均衡

两台服务代码相同，只是端口不同

将8001、8002两个服务启动，每个服务依然用ReentrantLock加锁，用Jmeter做并发测试，发现会出现数据一致性问题！

3. Redis实现分布式锁

3.1 方式一

取消单机锁，下面使用redis的set命令来实现分布式加锁

SET KEY VALUE [EX seconds] [PX milliseconds] [NX|XX]

  • EX seconds 设置指定的到期时间(以秒为单位)
  • PX milliseconds 设置指定的到期时间(以毫秒为单位)
  • 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 方式二（改进方式一）

在上面的代码中，如果程序在运行期间，部署了微服务jar包的机器突然挂了，代码层面根本就没有走到finally代码块，也就是说在宕机前，锁并没有被删除掉，这样的话，就没办法保证解锁

所以，这里需要对这个key加一个过期时间，Redis中设置过期时间有两种方法：

  • template.expire(REDIS_LOCK,10, TimeUnit.SECONDS)
  • template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS)

第一种方法需要单独的一行代码，且并没有与加锁放在同一步操作，所以不具备原子性，也会出问题

第二种方法在加锁的同时就进行了设置过期时间，所有没有问题，这里采用这种方式

调整下代码，在加锁的同时，设置过期时间：

// 为key加一个过期时间，其余代码不变
Boolean flag = template.opsForValue().setIfAbsent(REDIS_LOCK,value,10L,TimeUnit.SECONDS);

这种方式解决了因服务突然宕机而无法释放锁的问题。但再仔细想想，还是会有问题，下面进行改进。

3.3 方式三（改进方式二）

方式二设置了key的过期时间，解决了key

1. Datenkonsistenz auf einer Maschine

Die Architektur der Datenkonsistenz auf einer Maschine ist in der folgenden Abbildung dargestellt: Mehrere Clients können auf denselben Server zugreifen und eine Verbindung zu derselben Datenbank herstellen. 🎜

🎜🎜Szenariobeschreibung: Der Kunde simuliert den Prozess des Wareneinkaufs und setzt den Gesamtbestand in Redis auf 100 Stück. Mehrere Kunden kaufen gleichzeitig. 🎜

🎜

@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);
            }
        }
    }
}
🎜Verwenden Sie Jmeter, um Szenarien mit hoher Parallelität zu simulieren. Die Testergebnisse lauten wie folgt: 🎜

🎜🎜Die Testergebnisse zeigten, dass mehrere Benutzer dasselbe Produkt gekauft haben und es zu Dateninkonsistenzen kam! 🎜🎜Lösung: Sperren Sie im Falle einer einzelnen Anwendung gleichzeitige Vorgänge, um sicherzustellen, dass Datenvorgänge atomar sind. 🎜

  • synchronisiert
  • ReentrantLock Code>
@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('get',KEYS[1]) == ARGV[1] " +
                        "then " +
                        "return redis.call('del',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();
                }
            }
        }
    }
}

🎜

2. Verteilte Datenkonsistenz

🎜Das Obige löst das Datenkonsistenzproblem einer einzelnen Anwendung, aber wenn es verteilt ist. Was die Architekturbereitstellung betrifft, ist die Architektur wie folgt folgt: 🎜🎜 Bietet zwei Dienste, die Ports sind 8001, 8002, verbunden mit demselben Redis-Dienst, im Dienst gibt es einen Nginx vorne als Load Balancer🎜

🎜🎜Die beiden Dienstcodes sind gleich, aber die Ports sind unterschiedlich🎜🎜Starten Sie die beiden Dienste 8001 und 8002. Jeder Dienst ist weiterhin mit ReentrantLock gesperrt und Jmeter wird für Parallelitätstests verwendet. Es wurde festgestellt, dass es zu Datenkonsistenzproblemen kommen wird. 🎜

🎜

3. Redis implementiert verteilte Sperren

3.1 Methode 1

🎜Um die eigenständige Sperre aufzuheben, verwenden Sie den Befehl set von redis unten So implementieren Sie verteiltes Sperren🎜🎜SET KEY VALUE [EX seconds] [PX milliseconds] [NX|XX]🎜<ul> <li>EX seconds legt die angegebene Ablaufzeit (in Sekunden) fest</li>PX Millisekunden legt die angegebene Ablaufzeit in Millisekunden fest<li>NX Legt den Schlüssel nur fest, wenn der Schlüssel nicht existiert</li> <li>XX Legt den Schlüssel nur fest, wenn er bereits existiert</li> <li> li></li> </ul><pre class="brush:java;">@RestController public class IndexController8 { public static final String REDIS_LOCK = &quot;good_lock&quot;; @Autowired StringRedisTemplate template; @Autowired Redisson redisson; @RequestMapping(&quot;/buy8&quot;) public String index(){ RLock lock = redisson.getLock(REDIS_LOCK); lock.lock(); // 每个人进来先要进行加锁，key值为&quot;good_lock&quot; String value = UUID.randomUUID().toString().replace(&quot;-&quot;,&quot;&quot;); try{ String result = template.opsForValue().get(&quot;goods:001&quot;); int total = result == null ? 0 : Integer.parseInt(result); if (total &gt; 0) { // 如果在此处需要调用其他微服务，处理时间较长。。。 int realTotal = total - 1; template.opsForValue().set(&quot;goods:001&quot;, String.valueOf(realTotal)); System.out.println(&quot;购买商品成功，库存还剩：&quot; + realTotal + &quot;件， 服务端口为8001&quot;); return &quot;购买商品成功，库存还剩：&quot; + realTotal + &quot;件， 服务端口为8001&quot;; } else { System.out.println(&quot;购买商品失败，服务端口为8001&quot;); } return &quot;购买商品失败，服务端口为8001&quot;; }finally { if(lock.isLocked() &amp;&amp; lock.isHeldByCurrentThread()){ lock.unlock(); } } } }</pre>🎜Der obige Code kann das Problem der Datenkonsistenz in verteilten Architekturen lösen. Aber wenn Sie genauer darüber nachdenken, wird es immer noch Probleme geben. Lassen Sie uns unten Verbesserungen vornehmen. 🎜<h3>3.2 Methode 2 (Verbesserungsmethode 1)</h3>🎜Wenn im obigen Code der Computer, auf dem das Microservice-<code>jar-Paket bereitgestellt wird, während der Ausführung des Programms plötzlich hängen bleibt, wird der Code angezeigt Level Es hat den Codeblock finally überhaupt nicht erreicht, was bedeutet, dass die Sperre vor dem Herunterfahren nicht gelöscht wurde. In diesem Fall gibt es keine Möglichkeit, die Entsperrung zu garantieren🎜🎜Also, hier brauchen wir Um diesen -Schlüsselzu überprüfen, fügen Sie eine Ablaufzeit hinzu. Es gibt zwei Möglichkeiten, die Ablaufzeit in Redis festzulegen: 🎜
  • template.expire(REDIS_LOCK ,10, TimeUnit.SECONDS)
  • template.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS)
🎜Die erste Methode erfordert eine separate A-Codezeile und wird nicht im selben Schritt wie das Sperren platziert, ist also nicht atomar und verursacht Probleme. Die zweite Methode legt die Ablaufzeit gleichzeitig mit dem Sperren fest Dies ist kein Problem. Hier verwenden wir diese Methode: Passen Sie den Code an und legen Sie die Ablaufzeit beim Sperren fest: Aber wenn Sie genauer darüber nachdenken, wird es immer noch Probleme geben. Lassen Sie uns unten Verbesserungen vornehmen. 🎜

3.3 Methode drei (verbesserte Methode zwei)

🎜Methode zwei legt die Ablaufzeit von key fest, wodurch das Problem gelöst wird, dass key nicht gelöscht werden kann. aber das Problem Jetzt geht es wieder los 🎜

上面设置了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视频教程

Das obige ist der detaillierte Inhalt vonZusammenfassung von fünf Möglichkeiten zur Implementierung verteilter Sperren in Redis. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

lua nginx 架构 分布式 finally 并发 异步 redis 数据库 负载均衡
Stellungnahme：
Dieser Artikel ist reproduziert unter:jb51.net. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen
Vorheriger Artikel：Eine kurze Diskussion über die Gründe, warum Redis langsam ist, und wie man das Problem beheben kannNächster Artikel：Eine kurze Diskussion über die Gründe, warum Redis langsam ist, und wie man das Problem beheben kann

In Verbindung stehende Artikel

Mehr sehen