SpringBoot项目中实现Redis分布式锁的方法与最佳实践

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

spring:
  redis:
    host: localhost
    port: 6379
    # password: yourpassword # 如果设置了密码

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.TimeUnit;

@Component
public class RedisDistributedLock {

    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final String LOCK_PREFIX = "lock:";

    /**
     * 尝试获取分布式锁
     * @param lockKey 锁的业务Key，如 "order:123"
     * @param requestId 请求标识（可用UUID），用于安全释放锁
     * @param expireTime 锁的过期时间(毫秒)
     * @param waitTime 获取锁的最大等待时间(毫秒)
     * @return 是否获取成功
     */
    public boolean tryLock(String lockKey, String requestId, long expireTime, long waitTime) throws InterruptedException {
        String fullKey = LOCK_PREFIX + lockKey;
        long end = System.currentTimeMillis() + waitTime;

        while (System.currentTimeMillis() < end) { // 在等待时间内循环尝试
            // 使用 SET NX EX 命令原子性地尝试获取锁
            Boolean success = redisTemplate.opsForValue()
                    .setIfAbsent(fullKey, requestId, expireTime, TimeUnit.MILLISECONDS);
            if (Boolean.TRUE.equals(success)) {
                return true; // 获取锁成功
            }
            Thread.sleep(50); // 短暂休眠，避免活锁和CPU空转
        }
        return false; // 超时仍未获取到锁
    }

    /**
     * 释放分布式锁 (使用Lua脚本保证原子性)
     * @param lockKey 锁的业务Key
     * @param requestId 请求标识，必须与加锁时一致
     * @return 是否释放成功
     */
    public boolean unlock(String lockKey, String requestId) {
        String fullKey = LOCK_PREFIX + lockKey;
        // Lua脚本：如果键存在且值与预期相符，则删除它
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class);
        Long result = redisTemplate.execute(redisScript, Collections.singletonList(fullKey), requestId);
        return result != null && result == 1;
    }
}

@Service
public class OrderService {
    @Autowired
    private RedisDistributedLock redisLock;

    public void createOrder(String orderId) {
        String lockKey = "order_create:" + orderId;
        String requestId = UUID.randomUUID().toString(); // 生成唯一请求ID

        boolean locked = false;
        try {
            // 尝试获取锁，等待5秒，锁过期时间10秒
            locked = redisLock.tryLock(lockKey, requestId, 10000, 5000);
            if (locked) {
                // 成功获取锁，执行核心业务逻辑
                System.out.println("成功获取锁，执行订单创建逻辑...");
                // ... (你的业务代码)
            } else {
                // 获取锁失败，处理异常或重试
                throw new RuntimeException("系统繁忙，请稍后再试");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("获取锁被中断", e);
        } finally {
            // 释放锁，务必放在finally块中确保执行
            if (locked) {
                redisLock.unlock(lockKey, requestId);
            }
        }
    }
}

<dependency>
    <groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.27.0</version> <!-- 请使用最新稳定版本 -->
</dependency>

spring:
  redis:
    host: localhost
    port: 6379
# Redisson 通常会自动使用Spring Redis的配置

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Service
public class OrderServiceRedisson {

    @Autowired
    private RedissonClient redissonClient; // 直接注入RedissonClient

    public void createOrder(String orderId) {
        String lockKey = "order:lock:" + orderId;
        RLock lock = redissonClient.getLock(lockKey); // 获取RLock对象

        try {
            // 尝试加锁，最多等待5秒，锁持有时间10秒后自动解锁
            // boolean isLocked = lock.tryLock(5, 10, TimeUnit.SECONDS);

            // 更常用的方式是设置等待时间，但让看门狗自动续期（lockTime传入-1或使用无参lock()）
            boolean isLocked = lock.tryLock(5, TimeUnit.SECONDS);
            if (isLocked) {
                try {
                    // 成功获取锁，执行业务逻辑
                    System.out.println("Redisson锁获取成功，执行逻辑...");
                    // ... (你的业务逻辑，看门狗会为没有显式设置leaseTime的锁自动续期)
                } finally {
                    // 释放锁
                    if (lock.isHeldByCurrentThread()) {
                        lock.unlock();
                    }
                }
            } else {
                throw new RuntimeException("系统繁忙，请稍后再试");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("获取锁被中断", e);
        }
    }
}