Java 后端 / 系统课时
实现分布式锁
实现分布式锁
本课实现一个可用于多实例 Spring Boot 服务的 Redis 分布式锁。你将使用 Redisson 完成竞争等待、看门狗续期、当前线程校验释放和超时返回,并通过并发请求验证同一资源不会被重复处理。
学习目标
- 理解分布式锁的所有权、租约与续期边界
- 使用 Redisson 正确加锁和释放锁
- 通过并发请求验证竞争超时与业务互斥
明确锁要保护的临界区
分布式锁解决的是多个进程同时修改同一份共享资源的问题。锁键必须对应业务资源,例如 lock:stock:sku-1001,而不是给整个服务使用一个全局锁。临界区只应覆盖“读取共享状态、校验、更新并提交”这段不可并发执行的代码。
一个完整锁流程至少包含四个状态:等待获取、持有并执行、续期或自然过期、校验所有权后释放。只执行 SETNX 和 DEL 会留下两个风险:业务超过租约后锁提前失效,以及旧持有者误删新持有者的锁。

配置 Redisson 客户端
下面示例使用单节点 Redis。Maven 依赖中的版本是可工作的示例版本,企业项目应由统一依赖管理锁定并完成兼容性测试。
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.49.0</version>
</dependency>配置文件只提供 Redis 地址,实际生产环境还应通过密钥系统注入密码,并根据部署方式改成哨兵或集群配置。
spring:
data:
redis:
host: localhost
port: 6379以下配置显式创建 RedissonClient,便于看清连接来源。destroyMethod = "shutdown" 会在应用停止时关闭网络线程。
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> 替换为实际端口;两个响应的显示顺序可能互换。
curl -s -X POST http://localhost:<PORT>/stocks/sku-1001/deduct &
curl -s -X POST http://localhost:<PORT>/stocks/sku-1001/deduct &
wait预期结果
{"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,让下游只接受递增令牌更大的请求。