suchen

Heim >Java >javaLernprogramm >Verteiltes Schloss: 5 Fälle, vom Eintritt bis zur Beerdigung

Verteiltes Schloss: 5 Fälle, vom Eintritt bis zur Beerdigung

Java后端技术全栈
Java后端技术全栈nach vorne
2023-08-24 14:48:031033Durchsuche

Was ich heute mit Ihnen teilen möchte, ist verteilte Sperre In diesem Artikel werden fünf Fälle, Diagramme, Quellcodeanalysen usw. verwendet.

Gemeinsame synchronisierte Sperren, Sperren usw. basieren auf einem einzigen JVM ist implementiert, was sollten wir in einem verteilten Szenario tun? Zu diesem Zeitpunkt erschienen verteilte Sperren. JVM的实现的，如果分布式场景下怎么办呢？这时候分布式锁就出现了。

关于分布式的实现方案，在业界流行的有三种：

1、基于数据库

2、基于Redis

3、基于Zookeeper

另外，还有使用etcd、consul

In Bezug auf verteilte Implementierungslösungen gibt es drei beliebte in der Branche: 🎜🎜1 Basierend auf der Datenbank 🎜🎜2 Basierend auf Redis🎜🎜3. Basierend aufZookeeper🎜🎜Darüber hinaus gibt es auch die Verwendung von consul. 🎜

Am häufigsten in der Entwicklung verwendet wird Redis und Zookeeper hat zwei Lösungen, und die komplexeste der beiden Lösungen und die wahrscheinlichste, die Probleme verursacht, ist Redis Implementierungsplan, daher werden wir heute Redis和Zookeeper两种方案，并且两种方案中最复杂的，最容易出问题的就是Redis的实现方案，所以，我们今天就来把Redis实现方案都聊聊。

本文主要内容

Verteiltes Schloss: 5 Fälle, vom Eintritt bis zur Beerdigung


分布式锁场景

估计部分朋友还不太清楚分布式的使用场景，下面我简单罗列三种：

Verteiltes Schloss: 5 Fälle, vom Eintritt bis zur Beerdigung


案例1

如下代码模拟了下单减库存的场景，我们分析下在高并发场景下会存在什么问题

@RestController
public class IndexController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 模拟下单减库存的场景
     * @return
     */
    @RequestMapping(value = "/duduct_stock")
    public String deductStock(){
        // 从redis 中拿当前库存的值
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        if(stock > 0){
            int realStock = stock - 1;
            stringRedisTemplate.opsForValue().set("stock",realStock + "");
            System.out.println("扣减成功，剩余库存：" + realStock);
        }else{
            System.out.println("扣减失败，库存不足");
        }
        return "end";
    }
}

假设在Redis

Der Hauptinhalt dieses Artikels

Verteiltes Schloss: 5 Fälle, vom Eintritt bis zur Beerdigung

Szenario für verteilte Sperren span>

Es wird geschätzt, dass einige Freunde sich über verteilte Nutzungsszenarien nicht im Klaren sind. Ich werde im Folgenden kurz drei Typen auflisten:

Verteiltes Schloss: 5 Fälle, vom Eintritt bis zur Beerdigung🎜

Fall 1 span >🎜Der folgende Code simuliert das Szenario einer Bestellung zur Reduzierung des Lagerbestands. Lassen Sie uns analysieren, welche Probleme in Szenarien mit hoher Parallelität auftreten werden : break-word;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05);font-family: „Operator Mono " , Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96);">Der Anfangswert des Bestands in Redis beträgt 100. 🎜🎜Jetzt fordern 5 Clients diese Schnittstelle gleichzeitig an, und es kann zu einer gleichzeitigen Ausführung kommen🎜
int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));

这行代码，获取到的值都为100，紧跟着判断大于0后都进行-1操作，最后设置到redis 中的值都为99。但正常执行完成后redis中的值应为 95。

案例2-使用synchronized 实现单机锁

在遇到案例1的问题后，大部分人的第一反应都会想到加锁来控制事务的原子性，如下代码所示：

@RequestMapping(value = "/duduct_stock")
public String deductStock(){
    synchronized (this){
        // 从redis 中拿当前库存的值
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        if(stock > 0){
            int realStock = stock - 1;
            stringRedisTemplate.opsForValue().set("stock",realStock + "");
            System.out.println("扣减成功，剩余库存：" + realStock);
        }else{
            System.out.println("扣减失败，库存不足");
        }
    }
    return "end";
}

现在当有多个请求访问该接口时，同一时刻只有一个请求可进入方法体中进行库存的扣减，其余请求等候。

但我们都知道，synchronized 锁是属于JVM级别的，也就是我们俗称的“单机锁”。但现在基本大部分公司使用的都是集群部署，现在我们思考下以上代码在集群部署的情况下还能保证库存数据的一致性吗？

Verteiltes Schloss: 5 Fälle, vom Eintritt bis zur Beerdigung

答案是不能，如上图所示，请求经Nginx分发后，可能存在多个服务同时从Redis中获取库存数据，此时只加synchronized （单机锁）是无效的，并发越高，出现问题的几率就越大。

案例3-使用SETNX实现分布式锁

setnx：将 key 的值设为 value，当且仅当 key 不存在。

若给定 key 已经存在，则 setnx 不做任何动作。

使用setnx实现简单的分布式锁：

/**
 * 模拟下单减库存的场景
 * @return
 */
@RequestMapping(value = "/duduct_stock")
public String deductStock(){
    String lockKey = "product_001";
    // 使用 setnx 添加分布式锁
    // 返回 true 代表之前redis中没有key为 lockKey 的值，并已进行成功设置
    // 返回 false 代表之前redis中已经存在 lockKey 这个key了
    Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "wangcp");
    if(!result){
        // 代表已经加锁了
        return "error_code";
    }

    // 从redis 中拿当前库存的值
    int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
    if(stock > 0){
        int realStock = stock - 1;
        stringRedisTemplate.opsForValue().set("stock",realStock + "");
        System.out.println("扣减成功，剩余库存：" + realStock);
    }else{
        System.out.println("扣减失败，库存不足");
    }

    // 释放锁
    stringRedisTemplate.delete(lockKey);
    return "end";
}

我们知道 Redis 是单线程执行，现在再看案例2中的流程图时，哪怕高并发场景下多个请求都执行到了setnx的代码，redis会根据请求的先后顺序进行排列，只有排列在队头的请求才能设置成功。其它请求只能返回“error_code”。

当setnx设置成功后，可执行业务代码对库存扣减，执行完成后对锁进行释放。

我们再来思考下以上代码已经完美实现分布式锁了吗？能够支撑高并发场景吗？答案并不是，上面的代码还是存在很多问题的，离真正的分布式锁还差的很远。

我们分析一下，上面的代码存在的问题：

死锁：假如第一个请求在setnx加锁完成后，执行业务代码时出现了异常，那释放锁的代码就无法执行，后面所有的请求也都无法进行操作了。

针对死锁的问题，我们对代码再次进行优化，添加try-finally，在finally中添加释放锁代码，这样无论如何都会执行释放锁代码，如下所示：

/**
     * 模拟下单减库存的场景
     * @return
     */
@RequestMapping(value = "/duduct_stock")
public String deductStock(){
    String lockKey = "product_001";

    try{
        // 使用 setnx 添加分布式锁
        // 返回 true 代表之前redis中没有key为 lockKey 的值，并已进行成功设置
        // 返回 false 代表之前redis中已经存在 lockKey 这个key了
        Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, "wangcp");
        if(!result){
            // 代表已经加锁了
            return "error_code";
        }
        // 从redis 中拿当前库存的值
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        if(stock > 0){
            int realStock = stock - 1;
            stringRedisTemplate.opsForValue().set("stock",realStock + "");
            System.out.println("扣减成功，剩余库存：" + realStock);
        }else{
            System.out.println("扣减失败，库存不足");
        }
    }finally {
        // 释放锁
        stringRedisTemplate.delete(lockKey);
    }

    return "end";
}

经过改进后的代码是否还存在问题呢？我们思考正常执行的情况下应该是没有问题，但我们假设请求在执行到业务代码时服务突然宕机了，或者正巧你的运维同事重新发版，粗暴的 kill -9 掉了呢，那代码还能执行 finally 吗？

案例4-加入过期时间

针对想到的问题，对代码再次进行优化，加入过期时间，这样即便出现了上述的问题，在时间到期后锁也会自动释放掉，不会出现“死锁”的情况。

@RequestMapping(value = "/duduct_stock")
public String deductStock(){
    String lockKey = "product_001";

    try{
        Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lockKey,"wangcp",10,TimeUnit.SECONDS);
        if(!result){
            // 代表已经加锁了
            return "error_code";
        }
        // 从redis 中拿当前库存的值
        int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
        if(stock > 0){
            int realStock = stock - 1;
            stringRedisTemplate.opsForValue().set("stock",realStock + "");
            System.out.println("扣减成功，剩余库存：" + realStock);
        }else{
            System.out.println("扣减失败，库存不足");
        }
    }finally {
        // 释放锁
        stringRedisTemplate.delete(lockKey);
    }

    return "end";
}

现在我们再思考一下，给锁加入过期时间后就可以了吗？就可以完美运行不出问题了吗？

超时时间设置的10s真的合适吗？如果不合适设置多少秒合适呢？如下图所示

Verteiltes Schloss: 5 Fälle, vom Eintritt bis zur Beerdigung
Bilder

Angenommen, es liegen drei Anfragen gleichzeitig vor.

  • Anfrage 1 muss 15 Sekunden lang ausgeführt werden, nachdem sie zuerst gesperrt wurde. Die Sperre läuft jedoch ab und wird nach 10 Sekunden Ausführung aufgehoben.
  • Nachdem Anforderung 2 eingegeben wurde, wird sie gesperrt und ausgeführt. Wenn Anforderung 2 5 Sekunden lang ausgeführt wird, wird Anforderung 1 ausgeführt und die Sperre aufgehoben, aber die Sperre von Anforderung 2 wird zu diesem Zeitpunkt aufgehoben.
  • Anfrage 3 beginnt mit der Ausführung, wenn Anfrage 2 5 Sekunden lang ausgeführt wird. Wenn Anfrage 2 jedoch 3 Sekunden lang ausgeführt wird, wird die Sperre von Anfrage 3 aufgehoben.

Wir können das Problem erkennen, indem wir jetzt einfach drei Anfragen simulieren. Wenn es sich um ein Szenario mit wirklich hoher Parallelität handelt, kann die Sperre als „immer ungültig“ oder „permanent ungültig“ eingestuft werden.

Wo liegt also das konkrete Problem? In den folgenden Punkten zusammengefasst:

  • 1. Wenn eine Aufforderung zur Freigabe einer Sperre vorliegt, ist die freigegebene Sperre nicht Ihre eigene
  • 2. Die Zeitüberschreitung ist zu kurz und der Code wird automatisch freigegeben, bevor sie freigegeben wird ausgeführt.

Angesichts des Problems denken wir über die entsprechende Lösung nach:

  • Für Problem 1 denken wir darüber nach, eine eindeutige ID zu generieren, wenn die Anfrage eingeht, und verwenden die eindeutige ID als Wert der Sperre. und beim Freigeben zuerst den Erfassungsvergleich durchführen und dann fortfahren, wenn der Vergleich gleich ist, so dass das Problem der Freigabe anderer Anforderungssperren gelöst werden kann.
  • Als Antwort auf Frage 2: Ist es wirklich angemessen, dass wir die Ablaufzeit kontinuierlich verlängern? Wenn die Einstellung kurz ist, besteht das Problem der automatischen Freigabe im Laufe der Zeit. Wenn die Einstellung lang ist, wird die Sperre nach dem Herunterfahren für einen bestimmten Zeitraum nicht aufgehoben, obwohl kein „Deadlock“ mehr auftritt. Wie kann dieses Problem gelöst werden?

Fall 5 – Redisson verteiltes Schloss

Spring Boot集成RedissonSchritte

引入依赖 

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.6.5</version>
</dependency>

初始化客户端 

@Bean
public RedissonClient redisson(){
    // 单机模式
    Config config = new Config();
    config.useSingleServer().setAddress("redis://192.168.3.170:6379").setDatabase(0);
    return Redisson.create(config);
}

Redisson实现分布式锁 

@RestController
public class IndexController {

    @Autowired
    private RedissonClient redisson;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 模拟下单减库存的场景
     * @return
     */
    @RequestMapping(value = "/duduct_stock")
    public String deductStock(){
        String lockKey = "product_001";
        // 1.获取锁对象
        RLock redissonLock = redisson.getLock(lockKey);
        try{
            // 2.加锁
            redissonLock.lock();  // 等价于 setIfAbsent(lockKey,"wangcp",10,TimeUnit.SECONDS);
            // 从redis 中拿当前库存的值
            int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
            if(stock > 0){
                int realStock = stock - 1;
                stringRedisTemplate.opsForValue().set("stock",realStock + "");
                System.out.println("扣减成功，剩余库存：" + realStock);
            }else{
                System.out.println("扣减失败，库存不足");
            }
        }finally {
            // 3.释放锁
            redissonLock.unlock();
        }
        return "end";
    }
}

Redisson 分布式锁实现原理图

Verteiltes Schloss: 5 Fälle, vom Eintritt bis zur Beerdigung
图片

Redisson 底层源码分析

我们点击lock()方法，查看源码，最终看到以下代码

<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));
}

没错，加锁最终执行的就是这段lua 脚本语言。

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;

脚本的主要逻辑为：

  • exists 判断 key 是否存在
  • 当判断不存在则设置 key
  • 然后给设置的key追加过期时间

这样来看其实和我们前面案例中的实现方法好像没什么区别，但实际上并不是。

这段lua脚本命令在Redis中执行时，会被当成一条命令来执行，能够保证原子性，故要不都成功，要不都失败。

我们在源码中看到Redssion的许多方法实现中很多都用到了lua脚本，这样能够极大的保证命令执行的原子性。

下面是Redisson锁自动“续命”源码：

private void scheduleExpirationRenewal(final long threadId) {
    if (expirationRenewalMap.containsKey(getEntryName())) {
        return;
    }

    Timeout task = commandExecutor.getConnectionManager().newTimeout(new TimerTask() {
        @Override
        public void run(Timeout timeout) throws Exception {

            RFuture<Boolean> future = commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
                                                                     "if (redis.call(&#39;hexists&#39;, KEYS[1], ARGV[2]) == 1) then " +
                                                                     "redis.call(&#39;pexpire&#39;, KEYS[1], ARGV[1]); " +
                                                                     "return 1; " +
                                                                     "end; " +
                                                                     "return 0;",
                                                                     Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(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(), task) != null) {
        task.cancel();
    }
}

这段代码是在加锁后开启一个守护线程进行监听。Redisson超时时间默认设置30s，线程每10s调用一次判断锁还是否存在，如果存在则延长锁的超时时间。

现在，我们再回过头来看看案例5中的加锁代码与原理图，其实完善到这种程度已经可以满足很多公司的使用了，并且很多公司也确实是这样用的。但我们再思考下是否还存在问题呢？例如以下场景：

  • Wie wir alle wissenRedis Bei der tatsächlichen Bereitstellung und Verwendung werden sie in Clustern bereitgestellt. In Szenarien mit hoher Parallelität sperren wir. Nach dem Schreiben des Schlüssels auf den Master-Knoten stürzt der Master ab, bevor er mit dem Slave-Knoten synchronisiert wird. Die Original Der Slave-Knoten wird nach der Wahl zum neuen Master-Knoten. Zu diesem Zeitpunkt kann das Problem des Sperrfehlers auftreten.
    • Redis在实际部署使用时都是集群部署的，那在高并发场景下我们加锁，当把key写入到master节点后，master还未同步到slave节点时master宕机了，原有的slave节点经过选举变为了新的master节点，此时可能就会出现锁失效问题。

  • 通过分布式锁的实现机制我们知道，高并发场景下只有加锁成功的请求可以继续处理业务逻辑。那就出现了大伙都来加锁，但有且仅有一个加锁成功了，剩余的都在等待。其实分布式锁与高并发在语义上就是相违背的，我们的请求虽然都是并发，但Redis帮我们把请求进行了排队执行，也就是把我们的并行转为了串行。串行执行的代码肯定不存在并发问题了，但是程序的性能肯定也会因此受到影响。

    • 针对这些问题，我们再次思考解决方案

    • 在思考解决方案时我们首先想到CAP原则（一致性、可用性、分区容错性），那么现在的Redis就是满足AP(可用性、分区容错性)，如果想要解决该问题我们就需要寻找满足CP(一致性、分区容错性)的分布式系统。首先想到的就是Zookeeper，Zookeeper🎜Durch den Implementierungsmechanismus verteilter Sperren wissen wir, dass in Szenarien mit hoher Parallelität nur erfolgreich gesperrte Anforderungen die Geschäftslogik weiterhin verarbeiten können. Dann kommen alle zum Sperren, aber nur eine Sperre ist erfolgreich und der Rest wartet. Tatsächlich sind verteilte Sperren und hohe Parallelität semantisch widersprüchlich. Obwohl unsere Anforderungen alle gleichzeitig sind, Redis hilft uns, Anfragen zur Ausführung in die Warteschlange zu stellen, was bedeutet, dass wir unsere Parallelität in Serialisierung umwandeln. Bei seriell ausgeführtem Code treten definitiv keine Parallelitätsprobleme auf, die Leistung des Programms wird jedoch definitiv beeinträchtigt.

    Als Reaktion auf diese Probleme denken wir erneut über Lösungen nach

    🎜🎜🎜Wenn wir über Lösungen nachdenken, denken wir zuerst an die CAP-Prinzip (Konsistenz, Verfügbarkeit, Partitionstoleranz), dann ist der aktuelle Redis erfüllt AP (Verfügbarkeit, Partitionstoleranz). Wenn wir dieses Problem lösen wollen, müssen wir eine Lösung finden, die CP (Konsistenz, Partitionsfehlertoleranz) verteiltes System. Das erste, was mir in den Sinn kommt, ist Zookeeper , Zookeepers Inter-Cluster-Datensynchronisierungsmechanismus besteht darin, dass der Masterknoten beim Empfang der Daten nicht sofort eine Erfolgsrückmeldung an den Client zurückgibt. Zuerst werden die Daten mit den untergeordneten Knoten synchronisiert und dann Benachrichtigen Sie den Client erst, wenn mehr als die Hälfte der Knoten die Synchronisierung erfolgreich abgeschlossen haben.Und wenn der Masternode ausfällt, reicht es laut Zookeeper的Zab协议（Zookeeper原子广播）重新选举的主节点一定是已经同步成功的。

    那么问题来了，Redisson与Zookeeper分布式锁我们如何选择呢？答案是如果并发量没有那么高，可以用Zookeeper来做分布式锁，但是它的并发能力远远不如Redis。如果你对并发要求比较高的话，那就用Redis，偶尔出现的主从架构锁失效的问题其实是可以容忍的。

  • 关于第二个提升性能的问题，我们可以参考ConcurrentHashMap的锁分段技术的思想，例如我们代码的库存量当前为1000，那我们可以分为10段，每段100，然后对每段分别加锁，这样就可以同时执行10个请求的加锁与处理，当然有要求的同学还可以继续细分。但其实Redis的Qps已经达到10W+ in Szenarien ohne besonders hohe Parallelität völlig aus.

    • Das obige ist der detaillierte Inhalt vonVerteiltes Schloss: 5 Fälle, vom Eintritt bis zur Beerdigung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

    lua spring nginx spring boot 架构 分布式 jvm try 接口 finally 线程 cap 并发 redis zookeeper etcd consul 数据库
    Stellungnahme：
    Dieser Artikel ist reproduziert unter:Java后端技术全栈. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen
    Vorheriger Artikel：Benutzerdefinierte Ausnahmen in JavaNächster Artikel：Benutzerdefinierte Ausnahmen in Java

    In Verbindung stehende Artikel

    Mehr sehen