分布式锁加锁失败后的等待逻辑实现

CopyLower

于 2024-10-09 12:22:30 发布

阅读量318

点赞数 3

分类专栏：学习 Java 分布式文章标签：分布式 java

本文链接：https://blog.csdn.net/lssffy/article/details/142619753

版权

学习同时被 3 个专栏收录

248 篇文章 8 订阅

订阅专栏

Java

136 篇文章 2 订阅

订阅专栏

分布式

7 篇文章 0 订阅

订阅专栏

引言

在分布式系统中，分布式锁是用于确保多个进程或多个节点对共享资源的访问互斥的关键机制。当多个进程或节点需要对同一个资源进行修改时，分布式锁可以确保同一时间内只有一个进程能够访问资源，避免并发操作引发的数据不一致问题。

然而，在高并发场景下，当某个进程尝试获取锁失败时，需要有合适的等待逻辑来避免对系统资源的过度竞争。等待逻辑不仅要保证效率，还要避免死锁、资源占用过高等问题。本文将深入探讨分布式锁加锁失败后的等待逻辑实现，分析常见的实现方式及其优缺点，并结合代码示例详细讲解如何在实际项目中实现这一功能。

第一部分：分布式锁的基本概念

1.1 什么是分布式锁

分布式锁是一种在分布式环境中，用于保证多个节点在并发访问共享资源时的互斥机制。通过分布式锁，可以确保同一时间内只有一个节点能够对共享资源进行操作，从而保证数据的一致性。

1.2 分布式锁的应用场景

库存管理：在电商场景中，多个用户同时下单，系统需要确保库存不会因为并发操作出现超卖问题。
任务调度：在分布式任务调度系统中，多个节点可能会同时尝试处理同一个任务，需要确保任务不会被重复执行。
秒杀系统：在秒杀活动中，多个用户同时抢购同一个商品，需要使用分布式锁控制并发请求，确保库存的正确性。

1.3 分布式锁的实现方式

基于数据库实现：通过在数据库中插入或更新一条记录来实现锁机制。常用的数据库表方式，通过INSERT或UPDATE操作来加锁。
基于Redis实现：Redis提供的原子操作（如SETNX）可以用于实现分布式锁，适合高并发场景下的锁实现。
基于ZooKeeper实现：ZooKeeper的节点创建机制可以用于实现强一致性的分布式锁。

第二部分：分布式锁的加锁失败问题

2.1 加锁失败的原因

在分布式环境中，加锁失败通常发生在以下几种情况下：

锁已被其他节点持有：当多个节点同时尝试获取锁时，如果某个节点已经获取了锁，其他节点的加锁请求会失败。
超时时间太短：某些锁机制设有超时时间，锁可能在一个节点持有期间自动释放，导致加锁失败。
网络分区：在分布式系统中，网络分区问题可能导致某些节点的锁操作失效，从而引发加锁失败。

2.2 加锁失败的后果

加锁失败后，如果没有合适的等待和重试逻辑，可能会导致以下问题：

资源竞争过于激烈：多个节点频繁尝试获取锁，可能导致系统负载过高。
死锁：如果没有合理的锁定机制和重试逻辑，某些节点可能永远无法获取锁，从而导致死锁问题。
任务延迟：如果加锁失败的处理不当，某些任务可能无法及时完成，导致系统响应时间过长。

第三部分：加锁失败后的等待策略

在加锁失败后，需要设计合适的等待策略，以避免系统资源过度消耗并提高系统的效率。常见的等待策略有以下几种：

3.1 立即重试（Busy Waiting）

立即重试是最简单的一种等待策略。它会在加锁失败后，立即再次尝试获取锁，直到成功。这种策略在负载较低、锁冲突较少的场景中可以快速获取锁，但在高并发场景中，频繁重试会导致CPU资源的浪费。

优点：

实现简单。

缺点：

容易导致系统负载过高。

代码示例：

public void acquireLockWithBusyWaiting(String lockKey) {
    while (true) {
        boolean locked = tryAcquireLock(lockKey);
        if (locked) {
            System.out.println("成功获取锁：" + lockKey);
            break;
        }
        // 立即重试
    }
}

3.2 固定时间间隔重试

固定时间间隔重试是在加锁失败后，等待一段固定的时间，再次尝试获取锁。这种策略可以有效减少CPU资源的浪费，但在高并发下可能导致大量节点在同一时间尝试获取锁，增加系统压力。

优点：

相对减少系统负载。

缺点：

固定间隔可能不适合高并发场景。

代码示例：

public void acquireLockWithFixedInterval(String lockKey) throws InterruptedException {
    while (true) {
        boolean locked = tryAcquireLock(lockKey);
        if (locked) {
            System.out.println("成功获取锁：" + lockKey);
            break;
        }
        // 等待固定时间后重试
        Thread.sleep(100);  // 固定100毫秒
    }
}

3.3 指数退避算法（Exponential Backoff）

指数退避算法是一种动态调整等待时间的策略。在加锁失败后，系统会以指数级增长的时间间隔进行重试。这样可以有效避免在高并发下出现“雪崩效应”，即大量请求在同一时间段集中重试的问题。

优点：

减少高并发场景下的锁竞争。

缺点：

可能导致某些节点获取锁的延迟过长。

代码示例：

public void acquireLockWithExponentialBackoff(String lockKey) throws InterruptedException {
    int retryCount = 0;
    while (true) {
        boolean locked = tryAcquireLock(lockKey);
        if (locked) {
            System.out.println("成功获取锁：" + lockKey);
            break;
        }
        // 等待时间以指数级增长
        int waitTime = (int) Math.pow(2, retryCount) * 100;  // 100ms的基础等待时间
        Thread.sleep(waitTime);
        retryCount++;
    }
}

3.4 限制重试次数

在某些场景中，我们希望避免无限制的重试，可能会给系统带来额外的负担。此时可以限制重试的次数。如果达到最大重试次数依然获取失败，可以选择抛出异常或者记录日志以备后续处理。

优点：

避免无限重试，降低系统压力。

缺点：

某些任务可能在重试次数限制内未能成功获取锁。

代码示例：

public void acquireLockWithLimitedRetry(String lockKey, int maxRetries) throws InterruptedException {
    int retryCount = 0;
    while (retryCount < maxRetries) {
        boolean locked = tryAcquireLock(lockKey);
        if (locked) {
            System.out.println("成功获取锁：" + lockKey);
            return;
        }
        retryCount++;
        Thread.sleep(100);  // 固定等待时间
    }
    throw new RuntimeException("获取锁失败，超过最大重试次数");
}

3.5 自旋等待 + 自适应等待

自旋等待是一种较为灵活的等待策略，结合了立即重试和固定时间间隔重试的优点。自旋等待会在一段时间内频繁尝试获取锁，如果在短时间内无法获取，则进入休眠状态以减少资源消耗。通过这种方式，可以在轻度竞争下快速获取锁，而在高竞争场景下减少系统资源的浪费。

优点：

适用于轻度竞争和高竞争场景的平衡。

缺点：

实现较为复杂。

代码示例：

public void acquireLockWithSpinAndWait(String lockKey) throws InterruptedException {
    int spinCount = 0;
    while (true) {
        boolean locked = tryAcquireLock(lockKey);
        if (locked) {
            System.out.println("成功获取锁：" + lockKey);
            break;
        }
        spinCount++;
        if (spinCount < 10) {
            // 自旋等待，不进行休眠
            continue;
        }
        // 自旋10次后，进入休眠
        Thread.sleep(100);
    }
}

第四部分：分布式锁加锁失败后的等待逻辑优化

4.1 Redis分布式锁的实现

在分布式锁的实际应用中，Redis是常用的实现方式之一。通过Redis的

原子操作（如SETNX和EXPIRE），可以实现加锁和锁的自动释放。加锁失败后的等待逻辑也可以通过Redis命令来实现。

Redis加锁代码示例

public boolean tryAcquireLock(String lockKey, String requestId, int expireTime) {
    String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime);
    return "OK".equals(result);
}

Redis分布式锁的等待逻辑

我们可以将之前介绍的等待策略应用于Redis分布式锁的实现中。例如，使用固定时间间隔重试的策略：

public void acquireRedisLockWithRetry(String lockKey, String requestId, int expireTime) throws InterruptedException {
    while (true) {
        boolean locked = tryAcquireLock(lockKey, requestId, expireTime);
        if (locked) {
            System.out.println("成功获取锁：" + lockKey);
            break;
        }
        // 加锁失败，等待后重试
        Thread.sleep(100);
    }
}

4.2 ZooKeeper分布式锁的实现

ZooKeeper是另一个常用的分布式锁实现工具。ZooKeeper通过节点的创建和删除来实现锁机制。如果节点创建失败，则需要等待其他节点释放锁，等待过程中可以采用自旋、固定间隔或其他等待策略。

ZooKeeper加锁代码示例

public boolean tryAcquireZooKeeperLock(String lockPath) throws Exception {
    try {
        zooKeeper.create(lockPath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        return true;
    } catch (KeeperException.NodeExistsException e) {
        return false;
    }
}

ZooKeeper分布式锁的等待逻辑

public void acquireZooKeeperLockWithRetry(String lockPath) throws Exception {
    while (true) {
        boolean locked = tryAcquireZooKeeperLock(lockPath);
        if (locked) {
            System.out.println("成功获取锁：" + lockPath);
            break;
        }
        // 加锁失败，等待后重试
        Thread.sleep(100);
    }
}