// 1. 注入RedisTemplate（SpringBoot環(huán)境）
@Autowired
private RedisTemplate<String, Object> redisTemplate;

// 2. 互斥鎖核心方法（獲取鎖+查詢數(shù)據(jù)庫+更新緩存）
public Object getValueByMutexLock(String key) {
    // 第一步：查詢緩存
    Object value = redisTemplate.opsForValue().get(key);
    if (value != null) {
        return value; // 緩存存在，直接返回
    }
    
    // 第二步：緩存不存在，嘗試獲取分布式鎖
    String lockKey = "lock:" + key; // 鎖key，與業(yè)務(wù)key綁定，避免鎖沖突
    String lockValue = UUID.randomUUID().toString(); // 唯一值，用于釋放鎖
    boolean isLock = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, lockValue, 3, TimeUnit.SECONDS); // 鎖過期時間3秒（根據(jù)數(shù)據(jù)庫查詢耗時調(diào)整）
    
    if (isLock) {
        try {
            // 第三步：獲取鎖成功，查詢數(shù)據(jù)庫
            value = queryDatabase(key); // 自定義方法，查詢數(shù)據(jù)庫數(shù)據(jù)
            // 第四步：將數(shù)據(jù)庫數(shù)據(jù)寫入緩存，設(shè)置過期時間（避免再次擊穿）
            redisTemplate.opsForValue().set(key, value, 30, TimeUnit.MINUTES);
            return value;
        } finally {
            // 第五步：釋放鎖（必須在finally中，避免死鎖）
            // 對比value確保是自己的鎖，避免誤釋放他人的鎖
            if (lockValue.equals(redisTemplate.opsForValue().get(lockKey))) {
                redisTemplate.delete(lockKey);
            }
        }
    } else {
        // 第六步：獲取鎖失敗，重試（間隔100ms，避免頻繁重試）
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return getValueByMutexLock(key); // 遞歸重試，也可使用循環(huán)
    }
}

// 模擬數(shù)據(jù)庫查詢方法
private Object queryDatabase(String key) {
    // 實際業(yè)務(wù)中替換為真實數(shù)據(jù)庫查詢邏輯（如MyBatis查詢）
    return "數(shù)據(jù)庫查詢到的" + key + "對應(yīng)數(shù)據(jù)";
}

// 1. 定義緩存數(shù)據(jù)封裝類（封裝業(yè)務(wù)數(shù)據(jù)+邏輯過期時間）
@Data
public class CacheData<T> {
    // 業(yè)務(wù)數(shù)據(jù)
    private T data;
    // 邏輯過期時間（時間戳，單位：毫秒）
    private Long expireTime;
}

// 2. 注入依賴（SpringBoot環(huán)境）
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// 異步線程池（用于邏輯過期后異步更新緩存）
@Autowired
private ThreadPoolTaskExecutor asyncTaskExecutor;

// 3. 邏輯過期核心方法
public Object getValueByLogicalExpire(String key) {
    // 第一步：查詢Redis緩存（獲取封裝后的CacheData對象）
    CacheData<Object> cacheData = (CacheData<Object>) redisTemplate.opsForValue().get(key);
    if (cacheData == null) {
        // 緩存不存在（首次請求/緩存被手動刪除），此處可返回兜底數(shù)據(jù)或查詢數(shù)據(jù)庫
        return queryDatabase(key);
    }
    
    // 第二步：判斷邏輯過期時間是否已到
    Long currentTime = System.currentTimeMillis();
    if (currentTime < cacheData.getExpireTime()) {
        // 邏輯未過期，直接返回業(yè)務(wù)數(shù)據(jù)
        return cacheData.getData();
    }
    
    // 第三步：邏輯已過期，返回舊數(shù)據(jù)，同時異步更新緩存
    asyncTaskExecutor.execute(() -> {
        try {
            // 異步查詢數(shù)據(jù)庫最新數(shù)據(jù)
            Object newData = queryDatabase(key);
            // 重新封裝CacheData，設(shè)置新的邏輯過期時間（如30分鐘后）
            CacheData&lt;Object&gt; newCacheData = new CacheData<>();
            newCacheData.setData(newData);
            newCacheData.setExpireTime(System.currentTimeMillis() + 30 * 60 * 1000);
            // 更新Redis緩存（無物理過期時間）
            redisTemplate.opsForValue().set(key, newCacheData);
        } catch (Exception e) {
            // 異常處理（如日志記錄），避免異步任務(wù)失敗導(dǎo)致緩存無法更新
            log.error("邏輯過期緩存更新失敗，key:{}", key, e);
        }
    });
    
    // 直接返回舊數(shù)據(jù)，不阻塞當(dāng)前請求
    return cacheData.getData();
}

// 模擬數(shù)據(jù)庫查詢方法（與互斥鎖方案一致）
private Object queryDatabase(String key) {
    return "數(shù)據(jù)庫查詢到的" + key + "對應(yīng)數(shù)據(jù)";
}

// 4. 初始化緩存（緩存預(yù)熱，存入帶邏輯過期時間的數(shù)據(jù)）
public void initCache(String key) {
    Object data = queryDatabase(key);
    CacheData&lt;Object&gt; cacheData = new CacheData<>();
    cacheData.setData(data);
    // 設(shè)置邏輯過期時間（30分鐘）
    cacheData.setExpireTime(System.currentTimeMillis() + 30 * 60 * 1000);
    // 存入Redis，不設(shè)置物理過期時間
    redisTemplate.opsForValue().set(key, cacheData);
}