Java 后端 / 系统课时

实现分布式锁

实现分布式锁

本课实现一个可用于多实例 Spring Boot 服务的 Redis 分布式锁。你将使用 Redisson 完成竞争等待、看门狗续期、当前线程校验释放和超时返回,并通过并发请求验证同一资源不会被重复处理。

学习目标

  • 理解分布式锁的所有权、租约与续期边界
  • 使用 Redisson 正确加锁和释放锁
  • 通过并发请求验证竞争超时与业务互斥

明确锁要保护的临界区

分布式锁解决的是多个进程同时修改同一份共享资源的问题。锁键必须对应业务资源,例如 lock:stock:sku-1001,而不是给整个服务使用一个全局锁。临界区只应覆盖“读取共享状态、校验、更新并提交”这段不可并发执行的代码。

一个完整锁流程至少包含四个状态:等待获取、持有并执行、续期或自然过期、校验所有权后释放。只执行 SETNX 和 DEL 会留下两个风险:业务超过租约后锁提前失效,以及旧持有者误删新持有者的锁。

Redisson 分布式锁竞争与续期时序图

配置 Redisson 客户端

下面示例使用单节点 Redis。Maven 依赖中的版本是可工作的示例版本,企业项目应由统一依赖管理锁定并完成兼容性测试。

xml
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.49.0</version>
</dependency>

配置文件只提供 Redis 地址,实际生产环境还应通过密钥系统注入密码,并根据部署方式改成哨兵或集群配置。

yaml
spring:
  data:
    redis:
      host: localhost
      port: 6379

以下配置显式创建 RedissonClient,便于看清连接来源。destroyMethod = "shutdown" 会在应用停止时关闭网络线程。

java
package com.example.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class DistributedLockApplication {

    public static void main(String[] args) {
        SpringApplication.run(DistributedLockApplication.class, args);
    }

    @Bean(destroyMethod = "shutdown")
    RedissonClient redissonClient(
            @Value("${spring.data.redis.host}") String host,
            @Value("${spring.data.redis.port}") int port) {
        Config config = new Config();
        config.useSingleServer()
                .setAddress("redis://" + host + ":" + port);
        return Redisson.create(config);
    }

    public record DeductResponse(
            String status, int remaining, String message) {}

    @Service
    static class StockService {
        private final RedissonClient redisson;
        private final AtomicInteger stock = new AtomicInteger(10);

        StockService(RedissonClient redisson) {
            this.redisson = redisson;
        }

        DeductResponse deduct(String sku) {
            RLock lock = redisson.getLock("lock:stock:" + sku);
            boolean locked = false;
            try {
                // 未显式指定 leaseTime,持锁期间由 Watchdog 自动续期。
                locked = lock.tryLock(500, TimeUnit.MILLISECONDS);
                if (!locked) {
                    return new DeductResponse(
                            "BUSY", stock.get(), "资源正在处理,请稍后重试");
                }

                int current = stock.get();
                if (current <= 0) {
                    return new DeductResponse(
                            "SOLD_OUT", 0, "库存不足");
                }

                // 模拟数据库事务,时间长于另一个请求的等待上限。
                Thread.sleep(1200);
                int remaining = stock.decrementAndGet();
                return new DeductResponse(
                        "SUCCESS", remaining, null);
            } catch (InterruptedException ex) {
                Thread.currentThread().interrupt();
                return new DeductResponse(
                        "INTERRUPTED", stock.get(), "处理被中断");
            } finally {
                if (locked && lock.isHeldByCurrentThread()) {
                    lock.unlock();
                }
            }
        }
    }

    @RestController
    @RequestMapping("/stocks")
    static class StockController {
        private final StockService service;

        StockController(StockService service) {
            this.service = service;
        }

        @PostMapping("/{sku}/deduct")
        ResponseEntity<DeductResponse> deduct(@PathVariable String sku) {
            DeductResponse result = service.deduct(sku);
            if ("BUSY".equals(result.status())) {
                return ResponseEntity.status(409).body(result);
            }
            return ResponseEntity.ok(result);
        }
    }
}

代码使用 tryLock(500, TimeUnit.MILLISECONDS),表示最多等待 500 毫秒。该重载没有固定租约参数,Redisson 获锁后会启用 Watchdog;只要客户端进程存活且线程仍持有锁,就会续期。finally 中同时检查本地获锁标记和当前线程所有权,避免未获锁线程或其他线程错误解锁。

并发验证互斥效果

启动 Redis 和应用后,同时发起两个扣减请求。将 <PORT> 替换为实际端口;两个响应的显示顺序可能互换。

bash
curl -s -X POST http://localhost:<PORT>/stocks/sku-1001/deduct &
curl -s -X POST http://localhost:<PORT>/stocks/sku-1001/deduct &
wait

预期结果

text
{"status":"BUSY","remaining":10,"message":"资源正在处理,请稍后重试"}
{"status":"SUCCESS","remaining":9,"message":null}

只有一个请求进入 1.2 秒的临界区,另一个请求在等待 500 毫秒后返回 409。再次单独请求会继续扣减到 8,说明前一个成功请求已经在 finally 中释放锁。

选择续期还是固定租约

执行时长难以预测时,优先使用 Watchdog 模式。它能避免正常长事务执行到一半时锁过期,但进程长时间停顿、网络隔离或 Redis 故障仍可能导致所有权变化,因此业务写入最好再配合数据库唯一约束、乐观锁或幂等记录。

执行时间有明确上限时,可以使用 tryLock(waitTime, leaseTime, unit) 设置固定租约。此时不会自动续期,leaseTime 必须覆盖最坏执行时间并保留余量。租约过长会延迟故障恢复,租约过短则可能出现两个持有者先后进入临界区。

上线前检查边界

锁粒度应尽量细,但不能细到无法覆盖同一业务不变量。不要在锁内执行不可控的远程调用、文件上传或长时间计算;必须执行时应设置超时并准备补偿。获取失败应返回明确的“繁忙、重试或排队”语义,而不是无限等待。

Redis 锁不是数据库事务的替代品。扣库存、创建订单等关键写入仍需事务、唯一索引或版本号保证最终正确。对“旧持有者恢复后仍可能写入”的高风险场景,应使用 fencing token,让下游只接受递增令牌更大的请求。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

实现分布式锁

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通