Spring Boot 高并发：Redis 分布式锁实战指南与最佳实践

2601_95994719

503人浏览 · 2026-05-05 18:50:01

2601_95994719 · 2026-05-05 18:50:01 发布

在构建高并发系统时，我们经常遇到需要保证数据一致性的场景。例如，电商平台的秒杀活动，库存数量的扣减操作，如果多个用户同时访问，很容易出现超卖现象。传统的 Java 锁（如 synchronized、ReentrantLock）在单机环境下可以很好地解决这个问题，但在分布式环境下，由于锁的作用域仅限于单个 JVM 进程，无法跨服务器进行同步，因此需要引入分布式锁来保证数据的一致性。

Redis 作为高性能的键值存储数据库，凭借其原子性操作和高可用特性，成为了实现分布式锁的热门选择。例如，使用 SETNX (SET if Not eXists) 命令尝试获取锁，如果 key 不存在则设置成功，表示获取锁成功；如果 key 已经存在，则设置失败，表示获取锁失败。同时，需要考虑锁的自动释放，防止死锁情况的发生，通常会设置一个过期时间。

Redis 分布式锁原理深度剖析

SETNX 指令与锁的获取

Redis 提供了 SETNX 命令，当且仅当 key 不存在时，设置 key 的值。我们可以利用这个特性来实现分布式锁。当多个客户端同时尝试设置同一个 key 时，只有一个客户端能够成功，这就保证了锁的互斥性。

// 尝试获取锁，key 为锁的名称，value 可以是唯一标识，例如 UUIDString lockKey = "product:1001:lock";String clientId = UUID.randomUUID().toString();Long result = redisTemplate.execute((RedisCallback<Long>) connection -> connection.setNX(lockKey.getBytes(), clientId.getBytes()));if (result != null && result == 1L) {    // 获取锁成功    redisTemplate.expire(lockKey, 30, TimeUnit.SECONDS); // 设置过期时间，防止死锁    try {        // 执行业务逻辑        // ...    } finally {        // 释放锁        if (clientId.equals(redisTemplate.opsForValue().get(lockKey))) {            redisTemplate.delete(lockKey);        }    }} else {    // 获取锁失败    // ...}

锁的过期时间与 Watchdog 机制

为了防止程序在持有锁期间发生异常导致锁无法释放，从而造成死锁，需要为锁设置一个过期时间。但是，如果业务逻辑的执行时间超过了锁的过期时间，锁会被自动释放，其他客户端就有可能获取到锁，从而导致并发问题。为了解决这个问题，可以引入 Watchdog 机制，即一个后台线程定期检查锁的剩余过期时间，如果剩余时间小于某个阈值，则自动延长锁的过期时间。

Redlock 算法

Redlock 算法是由 Redis 作者 antirez 提出的一种更高级的分布式锁算法，它通过在多个独立的 Redis 节点上尝试获取锁，只有当超过半数的节点获取锁成功时，才认为获取锁成功。Redlock 算法能够提高锁的可用性和容错性，即使部分 Redis 节点发生故障，也能保证锁的正常工作。然而，Redlock 算法的实现较为复杂，性能也相对较低，需要根据实际场景进行权衡。

Spring Boot 整合 Redis 实现分布式锁：代码示例与配置详解

引入 Redis 依赖

首先，在 pom.xml 文件中引入 Spring Data Redis 的依赖：

<dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-data-redis</artifactId></dependency>

Redis 配置

在 application.properties 或 application.yml 文件中配置 Redis 连接信息：

spring:  redis:    host: localhost    port: 6379    password: your_redis_password    database: 0

编写 Redis 分布式锁工具类

@Componentpublic class RedisLock {    @Autowired    private StringRedisTemplate redisTemplate;    private static final String LOCK_PREFIX = "lock:";    /**     * 尝试获取锁     * @param lockName 锁的名称     * @param expireTime 锁的过期时间（秒）     * @return true 获取锁成功，false 获取锁失败     */    public boolean tryLock(String lockName, long expireTime) {        String lockKey = LOCK_PREFIX   lockName;        String clientId = UUID.randomUUID().toString();        Boolean success = redisTemplate.opsForValue().setIfAbsent(lockKey, clientId, expireTime, TimeUnit.SECONDS);        return Boolean.TRUE.equals(success);    }    /**     * 释放锁     * @param lockName 锁的名称     */    public void unlock(String lockName) {        String lockKey = LOCK_PREFIX   lockName;        String clientId = redisTemplate.opsForValue().get(lockKey);        if (clientId != null) {            redisTemplate.delete(lockKey);        }    }}

使用 Redis 分布式锁

@Servicepublic class ProductService {    @Autowired    private RedisLock redisLock;    public void decreaseStock(Long productId) {        String lockName = "product:"   productId   ":stock";        if (redisLock.tryLock(lockName, 30)) {            try {                // 查询库存                // 扣减库存                // 更新数据库            } finally {                redisLock.unlock(lockName);            }        } else {            // 获取锁失败，可以进行重试或返回错误信息        }    }}

实战避坑经验总结：高并发场景下的优化策略

选择合适的锁粒度：锁的粒度越细，并发性能越高，但实现复杂度也越高。需要根据实际场景进行权衡。例如，可以考虑使用基于 Hash 的分段锁来降低锁的竞争程度。
避免长时间持有锁：尽量缩短锁的持有时间，避免阻塞其他线程。可以将一些非核心的业务逻辑放在锁的外部执行。
使用 Lua 脚本执行原子操作：可以将获取锁和设置过期时间的操作放在一个 Lua 脚本中执行，保证原子性，避免出现锁被设置成功但过期时间未设置的情况。
考虑使用 Redisson 等高级 Redis 客户端：Redisson 提供了更丰富的功能，例如可重入锁、公平锁、读写锁等，能够简化分布式锁的实现。
监控 Redis 的性能：在高并发场景下，Redis 的性能直接影响分布式锁的性能。需要定期监控 Redis 的 CPU 使用率、内存使用率、网络带宽等指标，及时发现并解决性能瓶颈。例如，可以使用宝塔面板来监控服务器的资源使用情况。同时，需要根据实际情况调整 Redis 的配置参数，例如 maxmemory、maxclients 等，以提高 Redis 的性能。可以使用 Nginx 作为反向代理，并配置负载均衡，将请求分发到多个 Redis 节点上，以提高 Redis 的并发连接数和可用性。