Spring Boot 中的 Redis 分布式鎖
Spring Boot 中的 Redis 分布式鎖
在分布式系統(tǒng)中，多個進程同時訪問共享資源時，很容易出現(xiàn)并發(fā)問題。為了避免這些問題，我們可以使用分布式鎖來保證共享資源的獨占性。Redis 是一款非常流行的分布式緩存，它也提供了分布式鎖的功能。在 Spring Boot 中，我們可以很容易地使用 Redis 分布式鎖來管理并發(fā)訪問。
本文將介紹 Redis 分布式鎖的概念和原理，并說明如何在 Spring Boot 中使用它們。
Redis 分布式鎖的概念和原理
Redis 分布式鎖是一種基于 Redis 的分布式鎖解決方案。它的原理是利用 Redis 的原子性操作實現(xiàn)鎖的獲取和釋放，從而保證共享資源的獨占性。
在 Redis 中，我們可以使用 setnx 命令來實現(xiàn)分布式鎖。setnx 命令可以將一個鍵值對設置到 Redis 中，但只有在該鍵不存在的情況下才會設置成功。因此，我們可以將鎖的獲取和釋放分別實現(xiàn)為 setnx 和 del 命令。
以下是一個基本的 Redis 分布式鎖示例：
public class RedisDistributedLock {
private static final String LOCK_KEY_PREFIX = "lock:";
private static final long LOCK_EXPIRE_TIME = 30000L;
private RedisTemplate<String, Object> redisTemplate;
private String lockKey;
private String lockValue;
private boolean locked = false;
public RedisDistributedLock(RedisTemplate<String, Object> redisTemplate, String lockKey, String lockValue) {
this.redisTemplate = redisTemplate;
this.lockKey = LOCK_KEY_PREFIX + lockKey;
this.lockValue = lockValue;
}
public boolean lock() {
if (redisTemplate.opsForValue().setIfAbsent(lockKey, lockValue)) {
redisTemplate.expire(lockKey, LOCK_EXPIRE_TIME, TimeUnit.MILLISECONDS);
locked = true;
return true;
} else {
return false;
}
}
public void unlock() {
if (locked) {
redisTemplate.delete(lockKey);
}
}
}在這個示例中，我們定義了一個 RedisDistributedLock 類，它包含了 lock 和 unlock 兩個方法。lock 方法用于獲取鎖，unlock 方法用于釋放鎖。
lock 方法的實現(xiàn)邏輯如下：
- 使用 setIfAbsent 方法嘗試將鎖的鍵值對設置到 Redis 中。
- 如果設置成功，則調(diào)用 expire 方法設置鎖的過期時間，并標記 locked 為 true。
- 如果設置失敗，則說明鎖已經(jīng)被其他進程占用，返回 false。
unlock 方法的實現(xiàn)邏輯如下：
- 如果 locked 為 true，則使用 delete 方法刪除鎖的鍵值對。
Spring Boot 中的 Redis 分布式鎖實現(xiàn)
在 Spring Boot 中，我們可以使用 RedisTemplate 來訪問 Redis，并利用其提供的 setIfAbsent 和 delete 方法實現(xiàn) Redis 分布式鎖。
以下是一個基本的 Spring Boot + Redis 分布式鎖示例：
@RestController
public class UserController {
private RedisTemplate<String, Object> redisTemplate;
@Autowired
public UserController(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}
@GetMapping("/user/{id}")
public User getUser(@PathVariable("id") String id) throws InterruptedException {
RedisDistributedLock lock = new RedisDistributedLock(redisTemplate, "user:" + id, UUID.randomUUID().toString());
try {
while (!lock.lock()) {
Thread.sleep(100);
}
// 處理業(yè)務邏輯
return new User();
} finally {
lock.unlock();
}
}
}在這個示例中，我們定義了一個 UserController 類，其中包含了一個 getUser 方法，用于獲取用戶信息。在方法中，我們首先創(chuàng)建了一個 RedisDistributedLock 對象，然后在 while 循環(huán)中調(diào)用 lock 方法獲取鎖，直到獲取成功為止。在獲取鎖后，我們可以執(zhí)行相應的業(yè)務邏輯。最后，在 finally 塊中調(diào)用 unlock 方法釋放鎖。
需要注意的是，由于 Redis 分布式鎖是基于時間的，因此必須設置合適的過期時間。在示例中，我們將鎖的過期時間設置為 30 秒。
Redis 分布式鎖的優(yōu)化
在實際應用中，Redis 分布式鎖的性能和可靠性都非常重要。以下是幾個優(yōu)化 Redis 分布式鎖的方法：
1. 使用 Lua 腳本
在上面的示例中，我們使用了兩個 Redis 命令(setIfAbsent 和 expire)來實現(xiàn)分布式鎖，這將導致兩次網(wǎng)絡通信。在高并發(fā)情況下，這會增加 Redis 的負載，影響性能。為了避免這個問題，我們可以使用 Lua 腳本來將這兩個命令合并為一個原子操作。
以下是一個使用 Lua 腳本實現(xiàn) Redis 分布式鎖的示例：
public class RedisDistributedLock {
private static final String LOCK_SCRIPT = "if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then redis.call('pexpire', KEYS[1], ARGV[2]) return true else return false end";
private static final String UNLOCK_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
private static final String LOCK_KEY_PREFIX = "lock:";
private static final long LOCK_EXPIRE_TIME = 30000L;
private RedisTemplate<String, Object> redisTemplate;
private String lockKey;
private String lockValue;
private boolean locked = false;
private String lockScript;
private String unlockScript;
public RedisDistributedLock(RedisTemplate<String, Object> redisTemplate, String lockKey, String lockValue) {
this.redisTemplate = redisTemplate;
this.lockKey = LOCK_KEY_PREFIX + lockKey;
this.lockValue = lockValue;
this.lockScript = new DefaultRedisScript<>(LOCK_SCRIPT, Boolean.class).getScriptAsString();
this.unlockScript = new DefaultRedisScript<>(UNLOCK_SCRIPT, Long.class).getScriptAsString();
}
public boolean lock() {
Object result = redisTemplate.execute(new DefaultRedisScript<>(lockScript, Boolean.class), Collections.singletonList(lockKey), lockValue, LOCK_EXPIRE_TIME);
locked = (Boolean) result;
return locked;
}
public void unlock() {
if (locked) {
redisTemplate.execute(new DefaultRedisScript<>(unlockScript, Long.class), Collections.singletonList(lockKey), lockValue);
}
}
}在這個示例中，我們將 setIfAbsent 和 expire 命令合并為一個 Lua 腳本，并使用 RedisTemplate 的 execute 方法來執(zhí)行腳本。在 lock 方法中，我們執(zhí)行 LOCK_SCRIPT 腳本，如果返回 true，則表示獲取鎖成功。在 unlock 方法中，我們執(zhí)行 UNLOCK_SCRIPT 腳本來釋放鎖。
使用 Lua 腳本可以減少 Redis 的網(wǎng)絡通信次數(shù)，從而提高性能和可靠性。
2. 重試機制
由于分布式系統(tǒng)中存在網(wǎng)絡抖動等問題，Redis 分布式鎖的獲取和釋放可能會失敗。為了提高可靠性，我們可以使用重試機制來重復執(zhí)行獲取鎖和釋放鎖的操作。
以下是一個基本的重試機制實現(xiàn)示例：
public boolean lockWithRetry(int retryCount, long retryInterval) throws InterruptedException {
int count = 0;
while (count < retryCount) {
if (lock()) {
return true;
}
count++;
Thread.sleep(retryInterval);
}
return false;
}
public void unlockWithRetry(int retryCount, long retryInterval) throws InterruptedException {
int count = 0;
while (count < retryCount) {
try {
unlock();
break;
} catch (Exception e) {
count++;
Thread.sleep(retryInterval);
}
}
}在這個示例中，我們定義了 lockWithRetry 和 unlockWithRetry 兩個方法。lockWithRetry 方法會重復執(zhí)行 lock 方法，如果獲取鎖成功，則返回 true；否則，等待一段時間后重試。unlockWithRetry 方法會重復執(zhí)行 unlock 方法，如果釋放鎖成功，則結束重試；否則，等待一段時間后重試。
使用重試機制可以提高 Redis 分布式鎖的可靠性，保證在網(wǎng)絡抖動等情況下仍能正常工作。
3. 采用 Redlock 算法
Redis 分布式鎖的另一個問題是單點故障。由于 Redis 是單點的，如果 Redis 實例宕機，那么所有的分布式鎖都會失效。為了解決這個問題，我們可以采用 Redlock 算法。
Redlock 算法是 Redis 官方提出的一種分布式鎖算法。它通過使用多個 Redis 實例來避免單點故障的問題。具體來說，Redlock 算法首先獲取多個 Redis 實例上的鎖，然后比較這些鎖的時間戳，選擇時間戳最小的鎖為有效鎖。
以下是一個使用 Redlock 算法實現(xiàn) Redis 分布式鎖的示例：
public class RedisDistributedLock {
private static final String LOCK_KEY_PREFIX = "lock:";
private static final long LOCK_EXPIRE_TIME = 30000L;
private static final int RETRY_COUNT = 3;
private static final long RETRY_INTERVAL = 100L;
private RedisTemplate<String, Object> redisTemplate;
private String lockKey;
private String lockValue;
private boolean locked = false;
private List<RedisConnection> connections = new ArrayList<>();
public RedisDistributedLock(RedisTemplate<String, Object> redisTemplate, String lockKey, String lockValue) {
this.redisTemplate = redisTemplate;
this.lockKey = LOCK_KEY_PREFIX + lockKey;
this.lockValue = lockValue;
}
public boolean lock() {
for (int i = 0; i < RETRY_COUNT; i++) {
RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
connections.add(connection);
try {
byte[] keyBytes = redisTemplate.getKeySerializer().serialize(lockKey);
byte[] valueBytes = redisTemplate.getValueSerializer().serialize(lockValue);
long expireTime = System.currentTimeMillis() + LOCK_EXPIRE_TIME + 1;
for (int j = 0; j < connections.size(); j++) {
RedisConnection conn = connections.get(j);
if (j == connections.size() - 1) {
conn.set(keyBytes, valueBytes, Expiration.milliseconds(LOCK_EXPIRE_TIME), RedisStringCommands.SetOption.SET_IF_ABSENT);
} else {
conn.set(keyBytes, valueBytes, Expiration.milliseconds(LOCK_EXPIRE_TIME), RedisStringCommands.SetOption.SET_IF_ABSENT);
conn.pExpire(keyBytes, expireTime);
}
}
locked = true;
return true;
} catch (Exception e) {
// ignore
}
try {
Thread.sleep(RETRY_INTERVAL);
} catch (InterruptedException e) {
// ignore
}
}
return false;
}
public void unlock() {
for (RedisConnection connection : connections) {
try {
connection.del(redisTemplate.getKeySerializer().serialize(lockKey));
} catch (Exception e) {
// ignore
} finally {
connection.close();
}
}
connections.clear();
locked = false;
}
}在這個示例中，我們定義了一個 RedisDistributedLock 類，它使用多個 RedisConnection 來實現(xiàn) Redlock 算法。在 lock 方法中，我們首先獲取多個 RedisConnection，然后在這些連接上分別執(zhí)行 set 和 pExpire 命令。在執(zhí)行完這些命令后，我們比較這些鎖的時間戳，選擇時間戳最小的鎖為有效鎖。在 unlock 方法中，我們分別釋放每個 RedisConnection 上的鎖。
使用 Redlock 算法可以提高 Redis 分布式鎖的可靠性，避免單點故障的問題。
總結
在分布式系統(tǒng)中，使用分布式鎖是保證共享資源獨占性的重要方式。Redis 分布式鎖是一種基于 Redis 的分布式鎖解決方案，它通過利用 Redis 的原子性操作實現(xiàn)鎖的獲取和釋放，從而保證共享資源的獨占性。在 Spring Boot 中，我們可以很容易地使用 Redis 分布式鎖，通過 RedisTemplate 來操作 Redis 實例。在使用 Redis 分布式鎖時，需要注意鎖的粒度、鎖的超時時間、重試機制和 Redlock 算法，以保證分布式鎖的可靠性和高可用性。
到此這篇關于Spring Boot 中的 Redis 分布式鎖的文章就介紹到這了,更多相關Spring Boot 中的 Redis 分布式鎖內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
本文詳細介紹了Redis的過期鍵刪除策略和內(nèi)存淘汰策略,過期鍵刪除策略包括定時刪除、惰性刪除和定期刪除,具有一定的參考價值,感興趣的可以了解一下2025-11-11
內(nèi)存型數(shù)據(jù)庫Redis持久化小結
redis是一個支持持久化的內(nèi)存數(shù)據(jù)庫,也就是說redis需要經(jīng)常將內(nèi)存中的數(shù)據(jù)同步到磁盤來保證持久化.redis支持四種持久化方式,一是 Snapshotting（快照）也是默認方式,二是Append-only file（縮寫aof）的方式,三是虛擬內(nèi)存方式,四是diskstore方式.今天我們總結下前2種。2017-09-09
這篇文章主要介紹了redis 集群批量操作，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2021-04-04
在生活中很多時候都會用到延遲隊列，本文基于Redis延遲隊列的實現(xiàn)代碼，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-05-05
文章介紹了如何使用Redis實現(xiàn)一個簡單的延時任務隊列,通過Redis的有序集合特性來存儲和管理延時任務,通過定期檢查集合中小于等于當前時間的任務并執(zhí)行,可以實現(xiàn)延時任務的管理,感興趣的朋友跟隨小編一起看看吧2024-11-11
Redis分布式鎖中Redission底層實現(xiàn)方式
Redission基于Redis原子操作和Lua腳本實現(xiàn)分布式鎖,通過SETNX命令、看門狗續(xù)期、可重入機制及異常處理,確保鎖的可靠性和一致性,是Java項目中高效解決并發(fā)控制問題的優(yōu)選方案2025-08-08
Redis是一個高性能內(nèi)存數(shù)據(jù)庫,支持字符串、哈希、列表等數(shù)據(jù)結構,5.0版本新增Stream類型,提供消息隊列功能,支持消費者組和消息確認,本文介紹Redis從基礎到Stream消息隊列實戰(zhàn)指南,感興趣的朋友跟隨小編一起看看吧2026-03-03
這篇文章主要給大家介紹了關于redis中熱key問題該如何解決的相關資料，文中通過示例代碼介紹的非常詳細，對大家學習或者使用redis具有一定的參考學習價值，需要的朋友們下面來一起學習學習吧2019-05-05
Redis RDB是通過fork子進程生成內(nèi)存數(shù)據(jù)快照的持久化機制,采用寫時復制（COW）技術,確保數(shù)據(jù)一致性,優(yōu)點：性能高、恢復快；缺點：可能丟失最后一次持久化后的數(shù)據(jù),常用于備份,建議與AOF結合使用以兼顧安全與效率2025-09-09
Redis鎖的延期機制,通常被稱為看門狗機制,本文就拉介紹一下Redis的看門狗機制,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧2024-12-12