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

spring:
  redis:
    host: localhost
    port: 6379
    # password: yourpassword # 如果設(shè)置了密碼

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 鎖的業(yè)務(wù)Key，如 "order:123"
     * @param requestId 請求標(biāo)識（可用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) { // 在等待時間內(nèi)循環(huán)嘗試
            // 使用 SET NX EX 命令原子性地嘗試獲取鎖
            Boolean success = redisTemplate.opsForValue()
                    .setIfAbsent(fullKey, requestId, expireTime, TimeUnit.MILLISECONDS);
            if (Boolean.TRUE.equals(success)) {
                return true; // 獲取鎖成功
            }
            Thread.sleep(50); // 短暫休眠，避免活鎖和CPU空轉(zhuǎn)
        }
        return false; // 超時仍未獲取到鎖
    }

    /**
     * 釋放分布式鎖 (使用Lua腳本保證原子性)
     * @param lockKey 鎖的業(yè)務(wù)Key
     * @param requestId 請求標(biāo)識，必須與加鎖時一致
     * @return 是否釋放成功
     */
    public boolean unlock(String lockKey, String requestId) {
        String fullKey = LOCK_PREFIX + lockKey;
        // Lua腳本：如果鍵存在且值與預(yù)期相符，則刪除它
        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) {
                // 成功獲取鎖，執(zhí)行核心業(yè)務(wù)邏輯
                System.out.println("成功獲取鎖，執(zhí)行訂單創(chuàng)建邏輯...");
                // ... (你的業(yè)務(wù)代碼)
            } else {
                // 獲取鎖失敗，處理異?；蛑卦?
                throw new RuntimeException("系統(tǒng)繁忙，請稍后再試");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("獲取鎖被中斷", e);
        } finally {
            // 釋放鎖，務(wù)必放在finally塊中確保執(zhí)行
            if (locked) {
                redisLock.unlock(lockKey, requestId);
            }
        }
    }
}

<dependency>
    <groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.27.0</version> <!-- 請使用最新穩(wěn)定版本 -->
</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);

            // 更常用的方式是設(shè)置等待時間，但讓看門狗自動續(xù)期（lockTime傳入-1或使用無參lock()）
            boolean isLocked = lock.tryLock(5, TimeUnit.SECONDS);
            if (isLocked) {
                try {
                    // 成功獲取鎖，執(zhí)行業(yè)務(wù)邏輯
                    System.out.println("Redisson鎖獲取成功，執(zhí)行邏輯...");
                    // ... (你的業(yè)務(wù)邏輯，看門狗會為沒有顯式設(shè)置leaseTime的鎖自動續(xù)期)
                } finally {
                    // 釋放鎖
                    if (lock.isHeldByCurrentThread()) {
                        lock.unlock();
                    }
                }
            } else {
                throw new RuntimeException("系統(tǒng)繁忙，請稍后再試");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("獲取鎖被中斷", e);
        }
    }
}