手把手教你 SpringBoot 分布式鎖的實現(xiàn)

鷹兔牛熊眼 2020-06-27

展開全文

你知道的越多，不知道的就越多，業(yè)余的像一棵小草！

你來，我們一起精進(jìn)！你不來，我和你的競爭對手一起精進(jìn)！

編輯：業(yè)余草

來源：https:///632yIv

推薦：https://www./?p=5035

前言

前段時間面試了一個高級程序員，問他了一些分布式鎖的知識，回答的還不錯。后來進(jìn)了我們的團(tuán)隊，剛好讓他接手一個新項目，需要用到分布式鎖，我說這是你的強項，你來實現(xiàn)。

誰知，項目上線后，各種問題接連爆發(fā)出來。后來我找他談話，主要是說，千萬不要重復(fù)造輪子，直接吧 A 項目中的 Redisson 用法實現(xiàn)復(fù)制過來一份不就行了，干嘛非要自己搞一套，還搞出問題。。。

今天，我們一起來手把手來實現(xiàn)一個高效的 SpringBoot 分布式鎖！本文通過 Spring Boot 整合 redisson 來實現(xiàn)分布式鎖，并結(jié)合 demo 測試結(jié)果。

分析設(shè)計要點

當(dāng)我們在設(shè)計分布式鎖的時候，我們應(yīng)該考慮分布式鎖至少要滿足的一些條件，同時考慮如何高效的設(shè)計分布式鎖，這里我認(rèn)為以下幾點是必須要考慮的。

1、互斥

在分布式高并發(fā)的條件下，我們最需要保證，同一時刻只能有一個線程獲得鎖，這是最基本的一點。

2、防止死鎖

在分布式高并發(fā)的條件下，比如有個線程獲得鎖的同時，還沒有來得及去釋放鎖，就因為系統(tǒng)故障或者其它原因使它無法執(zhí)行釋放鎖的命令,導(dǎo)致其它線程都無法獲得鎖，造成死鎖。

所以分布式非常有必要設(shè)置鎖的有效時間，確保系統(tǒng)出現(xiàn)故障后，在一定時間內(nèi)能夠主動去釋放鎖，避免造成死鎖的情況。

3、性能

對于訪問量大的共享資源，需要考慮減少鎖等待的時間，避免導(dǎo)致大量線程阻塞。

所以在鎖的設(shè)計時，需要考慮兩點。

1、鎖的顆粒度要盡量小。比如你要通過鎖來減庫存，那這個鎖的名稱你可以設(shè)置成是商品的ID,而不是任取名稱。這樣這個鎖只對當(dāng)前商品有效,鎖的顆粒度小。

2、鎖的范圍盡量要小。比如只要鎖2行代碼就可以解決問題的，那就不要去鎖10行代碼了。

4、重入

我們知道ReentrantLock是可重入鎖，那它的特點就是：同一個線程可以重復(fù)拿到同一個資源的鎖。重入鎖非常有利于資源的高效利用。關(guān)于這點之后會做演示。

針對以上Redisson都能很好的滿足，下面就來使用它。

首先看下常規(guī)Redis鎖的處理圖

代碼實現(xiàn)

添加依賴


<dependency>

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

</dependency>

<dependency>

<groupId>org.redisson</groupId>
<artifactId>redisson-spring-boot-starter</artifactId>
<version>3.10.6</version>

</dependency>

配置信息

spring:
# redis
  redis:
    host: 47.103.5.190
    port: 6379
    jedis:
      pool:
# 連接池最大連接數(shù)（使用負(fù)值表示沒有限制）
        max-active: 100
# 連接池中的最小空閑連接
        max-idle: 10
# 連接池最大阻塞等待時間（使用負(fù)值表示沒有限制）
        max-wait: -1
# 連接超時時間（毫秒）
      timeout: 5000
#默認(rèn)是索引為0的數(shù)據(jù)庫
      database: 0

配置類

/**
* redisson 配置，下面是單節(jié)點配置：
*
* @author gourd
*/
@Configuration
publicclassRedissonConfig{
@Value('${spring.redis.host}')
privateString host;
@Value('${spring.redis.port}')
privateString port;
@Value('${spring.redis.password:}')
privateString password;
@Bean
publicRedissonClient redissonClient() {
Config config = newConfig();
//單節(jié)點
config.useSingleServer().setAddress('redis://'+ host + ':'+ port);
if(StringUtils.isEmpty(password)) {
config.useSingleServer().setPassword(null);
} else{
config.useSingleServer().setPassword(password);
}
//添加主從配置
// config.useMasterSlaveServers().setMasterAddress('').setPassword('').addSlaveAddress(new String[]{'',''});
// 集群模式配置 setScanInterval()掃描間隔時間，單位是毫秒, //可以用'rediss://'來啟用SSL連接
// config.useClusterServers().setScanInterval(2000).addNodeAddress('redis://127.0.0.1:7000', 'redis://127.0.0.1:7001').addNodeAddress('redis://127.0.0.1:7002');
returnRedisson.create(config);
}
}

Redisson 工具類

/**
 * redis分布式鎖幫助類
 *
 * @author gourd
 *
 */
publicclassRedisLockUtil{
privatestaticDistributedLocker distributedLocker = SpringContextHolder.getBean('distributedLocker',DistributedLocker.class);
/**
     * 加鎖
     * @param lockKey
     * @return
     */
publicstaticRLocklock(String lockKey) {
return distributedLocker.lock(lockKey);
}
/**
     * 釋放鎖
     * @param lockKey
     */
publicstaticvoid unlock(String lockKey) {
        distributedLocker.unlock(lockKey);
}
/**
     * 釋放鎖
     * @param lock
     */
publicstaticvoid unlock(RLocklock) {
        distributedLocker.unlock(lock);
}
/**
     * 帶超時的鎖
     * @param lockKey
     * @param timeout 超時時間   單位：秒
     */
publicstaticRLocklock(String lockKey, int timeout) {
return distributedLocker.lock(lockKey, timeout);
}
/**
     * 帶超時的鎖
     * @param lockKey
     * @param unit 時間單位
     * @param timeout 超時時間
     */
publicstaticRLocklock(String lockKey, int timeout,TimeUnit unit ) {
return distributedLocker.lock(lockKey, unit, timeout);
}
/**
     * 嘗試獲取鎖
     * @param lockKey
     * @param waitTime 最多等待時間
     * @param leaseTime 上鎖后自動釋放鎖時間
     * @return
     */
publicstaticboolean tryLock(String lockKey, int waitTime, int leaseTime) {
return distributedLocker.tryLock(lockKey, TimeUnit.SECONDS, waitTime, leaseTime);
}
/**
     * 嘗試獲取鎖
     * @param lockKey
     * @param unit 時間單位
     * @param waitTime 最多等待時間
     * @param leaseTime 上鎖后自動釋放鎖時間
     * @return
     */
publicstaticboolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
return distributedLocker.tryLock(lockKey, unit, waitTime, leaseTime);
}
/**
     * 獲取計數(shù)器
     *
     * @param name
     * @return
     */
publicstaticRCountDownLatch getCountDownLatch(String name){
return distributedLocker.getCountDownLatch(name);
}
/**
     * 獲取信號量
     *
     * @param name
     * @return
     */
publicstaticRSemaphore getSemaphore(String name){
return distributedLocker.getSemaphore(name);
}
}

底層封裝

/**
* @author gourd
*/
publicinterfaceDistributedLocker{
RLocklock(String lockKey);
RLocklock(String lockKey, int timeout);
RLocklock(String lockKey, TimeUnit unit, int timeout);
boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime);
void unlock(String lockKey);
void unlock(RLocklock);
}
/**
* @author gourd
*/
@Component
publicclassRedisDistributedLockerimplementsDistributedLocker{
@Autowired
privateRedissonClient redissonClient;
@Override
publicRLocklock(String lockKey) {
RLocklock= redissonClient.getLock(lockKey);
lock.lock();
returnlock;
}
@Override
publicRLocklock(String lockKey, int leaseTime) {
RLocklock= redissonClient.getLock(lockKey);
lock.lock(leaseTime, TimeUnit.SECONDS);
returnlock;
}
@Override
publicRLocklock(String lockKey, TimeUnit unit ,int timeout) {
RLocklock= redissonClient.getLock(lockKey);
lock.lock(timeout, unit);
returnlock;
}
@Override
publicboolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
RLocklock= redissonClient.getLock(lockKey);
try{
returnlock.tryLock(waitTime, leaseTime, unit);
} catch(InterruptedException e) {
returnfalse;
}
}
@Override
publicvoid unlock(String lockKey) {
RLocklock= redissonClient.getLock(lockKey);
lock.unlock();
}
@Override
publicvoid unlock(RLocklock) {
lock.unlock();
}
}

測試

模擬并發(fā)測試

/**
 * redis分布式鎖控制器
 * @author gourd
 * @since 2019-07-30
 */
@RestController
@Api(tags = 'redisson', description = 'redis分布式鎖控制器')
@RequestMapping('/redisson')
@Slf4j
publicclassRedissonLockController{
/**
     * 鎖測試共享變量
     */
privateInteger lockCount = 10;
/**
     * 無鎖測試共享變量
     */
privateInteger count = 10;
/**
     * 模擬線程數(shù)
     */
privatestaticint threadNum = 10;
/**
     * 模擬并發(fā)測試加鎖和不加鎖
     * @return
     */
@GetMapping('/test')
@ApiOperation(value = '模擬并發(fā)測試加鎖和不加鎖')
publicvoidlock(){
// 計數(shù)器
finalCountDownLatch countDownLatch = newCountDownLatch(1);
for(int i = 0; i < threadNum; i ++) {
MyRunnable myRunnable = newMyRunnable(countDownLatch);
Thread myThread = newThread(myRunnable);
            myThread.start();
}
// 釋放所有線程
        countDownLatch.countDown();
}
/**
     * 加鎖測試
     */
privatevoid testLockCount() {
String lockKey = 'lock-test';
try{
// 加鎖，設(shè)置超時時間2s
RedisLockUtil.lock(lockKey,2, TimeUnit.SECONDS);
            lockCount--;
            log.info('lockCount值：'+lockCount);
}catch(Exception e){
            log.error(e.getMessage(),e);
}finally{
// 釋放鎖
RedisLockUtil.unlock(lockKey);
}
}
/**
     * 無鎖測試
     */
privatevoid testCount() {
        count--;
        log.info('count值：'+count);
}
publicclassMyRunnableimplementsRunnable{
/**
         * 計數(shù)器
         */
finalCountDownLatch countDownLatch;
publicMyRunnable(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
}
@Override
publicvoid run() {
try{
// 阻塞當(dāng)前線程，直到計時器的值為0
                countDownLatch.await();
} catch(InterruptedException e) {
                log.error(e.getMessage(),e);
}
// 無鎖操作
            testCount();
// 加鎖操作
            testLockCount();
}
}
}