2. 程式人生 > 程式設計 >基於springboot實現redis分散式鎖的方法

基於springboot實現redis分散式鎖的方法

阿新 • • 發佈：2020-11-28

在公司的專案中用到了分散式鎖，但只會用卻不明白其中的規則
所以寫一篇文章來記錄
使用場景：交易服務，使用redis分散式鎖，防止重複提交訂單，出現超賣問題

分散式鎖的實現方式

  1. 基於資料庫樂觀鎖/悲觀鎖
  2. Redis分散式鎖（本文）
  3. Zookeeper分散式鎖

redis是如何實現加鎖的？

在redis中，有一條命令，實現鎖

SETNX key value

該命令的作用是將 key 的值設為 value ，當且僅當 key 不存在。若給定的 key 已經存在，則 SETNX 不做任何動作。設定成功，返回 1 ；設定失敗，返回 0

使用 redis 來實現鎖的邏輯就是這樣的

執行緒 1 獲取鎖 -- > setnx lockKey lockvalue
-- > 1 獲取鎖成功
執行緒 2 獲取鎖 -- > setnx lockKey lockvalue
-- > 0 獲取鎖失敗 （繼續等待，或者其他邏輯）
執行緒 1 釋放鎖 -- >
執行緒 2 獲取鎖 -- > setnx lockKey lockvalue
-- > 1 獲取成功

接下來我們將基於springboot實現redis分散式鎖

1. 引入redis、springmvc、lombok依賴

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.0</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <groupId>cn.miao.redis</groupId>
  <artifactId>springboot-caffeine-demo</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>springboot-redis-lock-demo</name>
  <description>Demo project for Redis Distribute Lock</description>

  <properties>
    <java.version>1.8</java.version>
  </properties>

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

    <!--redis-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
      <version>2.1.4.RELEASE</version>
    </dependency>

    <!--springMvc-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <version>2.3.3.RELEASE</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.12</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>

2. 新建RedisDistributedLock.java並書寫加鎖解鎖邏輯

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;

import java.nio.charset.StandardCharsets;

/**
 * @author miao
 * redis 加鎖工具類
 */
@Slf4j
public class RedisDistributedLock {

  /**
   * 超時時間
   */
  private static final long TIMEOUT_MILLIS = 15000;

  /**
   * 重試次數
   */
  private static final int RETRY_TIMES = 10;

  /***
   * 睡眠時間
   */
  private static final long SLEEP_MILLIS = 500;

  /**
   * 用來加鎖的lua指令碼
   * 因為新版的redis加鎖操作已經為原子性操作
   * 所以放棄使用lua指令碼
   */
  private static final String LOCK_LUA =
      "if redis.call(\"setnx\",KEYS[1],ARGV[1]) == 1 " +
          "then " +
          "  return redis.call('expire',ARGV[2]) " +
          "else " +
          "  return 0 " +
          "end";

  /**
   * 用來釋放分散式鎖的lua指令碼
   * 如果redis.get(KEYS[1]) == ARGV[1],則redis delete KEYS[1]
   * 否則返回0
   * KEYS[1],ARGV[1] 是引數，我們只調用的時候 傳遞這兩個引數就可以了
   * KEYS[1] 主要用來傳遞在redis 中用作key值的引數
   * ARGV[1] 主要用來傳遞在redis中用做 value值的引數
   */
  private static final String UNLOCK_LUA =
      "if redis.call(\"get\",KEYS[1]) == ARGV[1] "
          + "then "
          + "  return redis.call(\"del\",KEYS[1]) "
          + "else "
          + "  return 0 "
          + "end ";

  /**
   * 檢查 redisKey 是否上鎖
   *
   * @param redisKey redisKey
   * @param template template
   * @return Boolean
   */
  public static Boolean isLock(String redisKey,String value,RedisTemplate<Object,Object> template) {

    return lock(redisKey,value,template,RETRY_TIMES);
  }

  private static Boolean lock(String redisKey,Object> template,int retryTimes) {

    boolean result = lockKey(redisKey,template);

    while (!(result) && retryTimes-- > 0) {
      try {

        log.debug("lock failed,retrying...{}",retryTimes);
        Thread.sleep(RedisDistributedLock.SLEEP_MILLIS);
      } catch (InterruptedException e) {

        return false;
      }
      result = lockKey(redisKey,template);
    }

    return result;
  }


  private static Boolean lockKey(final String key,final String value,Object> template) {
    try {

      RedisCallback<Boolean> callback = (connection) -> connection.set(
          key.getBytes(StandardCharsets.UTF_8),value.getBytes(StandardCharsets.UTF_8),Expiration.milliseconds(RedisDistributedLock.TIMEOUT_MILLIS),RedisStringCommands.SetOption.SET_IF_ABSENT
      );

      return template.execute(callback);
    } catch (Exception e) {

      log.info("lock key fail because of ",e);
    }

    return false;
  }


  /**
   * 釋放分散式鎖資源
   *
   * @param redisKey key
   * @param value  value
   * @param template redis
   * @return Boolean
   */
  public static Boolean releaseLock(String redisKey,Object> template) {
    try {
      RedisCallback<Boolean> callback = (connection) -> connection.eval(
          UNLOCK_LUA.getBytes(),ReturnType.BOOLEAN,1,redisKey.getBytes(StandardCharsets.UTF_8),value.getBytes(StandardCharsets.UTF_8)
      );

      return template.execute(callback);
    } catch (Exception e) {

      log.info("release lock fail because of ",e);
    }

    return false;
  }

}

補充：
1. spring-data-redis 有StringRedisTempla和RedisTemplate兩種，但是我選擇了RedisTemplate，因為他比較萬能。他們的區別是：當你的redis資料庫裡面本來存的是字串資料或者你要存取的資料就是字串型別資料的時候，那麼你就使用StringRedisTemplate即可， 但是如果你的資料是複雜的物件型別，而取出的時候又不想做任何的資料轉換，直接從Redis裡面取出一個物件，那麼使用RedisTemplate是 更好的選擇。
2. 選擇lua指令碼是因為，指令碼執行是原子性的，在指令碼執行期間沒有客戶端可以操作，所以在釋放鎖的時候用了lua指令碼，
而redis最新版加鎖時保證了Redis值和自動過期時間的原子性，所用沒用lua指令碼

3. 建立測試類 TestController

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author miao
 */
@RestController
@Slf4j
public class TestController {

  @Resource
  private RedisTemplate<Object,Object> redisTemplate;

  @PostMapping("/order")
  public String createOrder() throws InterruptedException {

    log.info("開始建立訂單");

    Boolean isLock = RedisDistributedLock.isLock("testLock","456789",redisTemplate);

    if (!isLock) {

      log.info("鎖已經被佔用");
      return "fail";
    } else {
      //.....處理邏輯
    }

    Thread.sleep(10000);
    //一定要記得釋放鎖，否則會出現問題
    RedisDistributedLock.releaseLock("testLock",redisTemplate);

    return "success";
  }
}

4. 使用postman進行測試

基於springboot實現redis分散式鎖的方法

基於springboot實現redis分散式鎖的方法

基於springboot實現redis分散式鎖的方法

5. redis分散式鎖的缺點

上面我們說的是redis，是單點的情況。如果是在redis sentinel叢集中情況就有所不同了。在redis sentinel叢集中，我們具有多臺redis，他們之間有著主從的關係，例如一主二從。我們的set命令對應的資料寫到主庫，然後同步到從庫。當我們申請一個鎖的時候，對應就是一條命令 setnx mykey myvalue ，在redis sentinel叢集中，這條命令先是落到了主庫。假設這時主庫down了，而這條資料還沒來得及同步到從庫，sentinel將從庫中的一臺選舉為主庫了。這時，我們的新主庫中並沒有mykey這條資料，若此時另外一個client執行 setnx mykey hisvalue,也會成功，即也能得到鎖。這就意味著，此時有兩個client獲得了鎖。這不是我們希望看到的，雖然這個情況發生的記錄很小，只會在主從failover的時候才會發生，大多數情況下、大多數系統都可以容忍，但是不是所有的系統都能容忍這種瑕疵。

6.redis分散式鎖的優化

為了解決故障轉移情況下的缺陷，Antirez 發明了 Redlock 演算法，使用redlock演算法，需要多個redis例項，加鎖的時候，它會想多半節點發送 setex mykey myvalue 命令，只要過半節點成功了，那麼就算加鎖成功了。釋放鎖的時候需要想所有節點發送del命令。這是一種基於【大多數都同意】的一種機制。感興趣的可以查詢相關資料。在實際工作中使用的時候，我們可以選擇已有的開源實現，python有redlock-py，java 中有Redisson redlock。

redlock確實解決了上面所說的“不靠譜的情況”。但是，它解決問題的同時，也帶來了代價。你需要多個redis例項，你需要引入新的庫 程式碼也得調整，效能上也會有損。所以，果然是不存在“完美的解決方案”，我們更需要的是能夠根據實際的情況和條件把問題解決了就好。

我大致講清楚了redis分散式鎖方面的問題（日後如果有新的領悟就繼續更新）。更多相關springboot redis分散式鎖內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！

相關推薦

基於springboot實現redis分散式鎖的方法

在公司的專案中用到了分散式鎖，但只會用卻不明白其中的規則 所以寫一篇文章來記錄

springBoot實現redis分散式鎖

  　　　參考：https://blog.csdn.net/weixin_44634197/article/details/108308395 、、   使用redis的set命令帶NX(not exist)引數實現分散式鎖

基於SpringBoot AOP面向切面程式設計實現Redis分散式鎖

基於SpringBoot AOP面向切面程式設計實現Redis分散式鎖 基於SpringBoot AOP面向切面程式設計實現Redis分散式鎖

SpringBoot AOP+redis分散式鎖實現防止使用者重複發起請求

前言：分散式鎖一般有三種實現方式：1. 資料庫樂觀鎖；2. 基於Redis的分散式鎖；3. 基於ZooKeeper的分散式鎖。本文介紹的是第二種。

如何在 SpringBoot 中用註解實現 Redis 分散式鎖？

一、業務背景 有些業務請求，屬於耗時操作，需要加鎖，防止後續的併發操作，同時對資料庫的資料進行操作，需要避免對之前的業務造成影響。

SpringBoot系列-redis分散式鎖實現

技術標籤：SpringBootjavaredis多執行緒 SpringBoot系列-redis分散式鎖實現 SpringBoot整合Redis分散式鎖教程前言一、技術介紹1.Redis是什麼？2.分散式鎖是什麼？

基於Redisson框架實現redis分散式鎖

1、起初 引入依賴 1 2 3 4 5 <!-- spring boot redis快取引入 -->         <dependency>

SpringBoot 整合 redis 分散式鎖

繼上一篇 SpringBoot 整合 redis 踩坑日誌之後，又學習了 redis 分散式鎖，那為什麼需要分散式鎖？

Curator--2 基於ZK實現的分散式鎖

技術標籤：分散式 curator是Netflix公司開源的一個ZooKeeper客戶端封裝。curator 很好的實現了分散式鎖，curator 提供了InterProcessMutex 這樣一個 api。除了分散式鎖之外，還提供了 leader 選舉、分散式佇列等

實現redis分散式鎖

因專案需要，需要對快取中資料進行頻繁的讀寫操作，為了防止併發寫覆蓋問題，在程式中加了redis實現的分散式鎖來控制併發寫的場景。

python實現redis分散式鎖

1 import time 2 import redis 3 from redis.exceptions import WatchError 4 5 6 class RedisUtil(): 7def __init__(self):

Redis 如何實現redis分散式鎖

1、redis設定key時上鎖 參考怎樣實現redis分散式鎖？ package com.test; import com.utils.JedisUtil;

談談Redis分散式鎖的正確實現方法

前言 最近在參加學校安排的實訓任務，我們小組需完成一套分散式&微服務跨境電商，雖然這題目看起來有點老套，並且隊友多是 Java 技術棧，所以我光榮（被迫）

基於Redis分散式鎖的實現程式碼

概述 目前幾乎很多大型網站及應用都是分散式部署的，分散式場景中的資料一致性問題一直是一個比較重要的話題。分散式的CAP理論告訴我們“任何一個分散式系統都無法同時滿足一致性（Consistency）、可用性（Availabil

基於redis分散式鎖實現秒殺功能

最近在專案中遇到了類似“秒殺”的業務場景，在本篇部落格中，我將用一個非常簡單的demo，闡述實現所謂“秒殺”的基本思路。

Redis分散式鎖的正確實現方法總結

分散式鎖一般有三種實現方式： 1、資料庫樂觀鎖； 2、基於Redis的分散式鎖； 3、基於ZooKeeper的分散式鎖。

springboot redis 分散式鎖實現定時任務

package com.rdj.distributelock; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication;

redis分散式鎖的go-redis實現方法詳解

在分散式的業務中,如果有的共享資源需要安全的被訪問和處理,那就需要分散式鎖

基於資料庫、redis和zookeeper實現的分散式鎖

基於資料庫 基於資料庫（MySQL）的方案，一般分為3類：基於表記錄、樂觀鎖和悲觀鎖

oj程式碼runtime error_基於 Redis 分散式鎖實現“秒殺”（含程式碼）

技術標籤：oj程式碼runtime error 業務場景一些可能的實現何為分散式鎖具體的實現需要考慮的問題talk is cheap,show me the code小結