2. 程式人生 > >分散式的redis鎖

分散式的redis鎖

阿新 • • 發佈：2018-12-18

    springboot2本地鎖實踐一文中提到用Guava Cache實現鎖機制，但在叢集中就行不通了，所以我們還一般要藉助類似Redis、ZooKeeper 之類的中介軟體實現分散式鎖，下面我們將利用自定義註解、Spring Aop、Redis Cache 實現分散式鎖。

專案程式碼結構整體圖

一、匯入依賴

在 pom.xml 中新增上 starter-web、starter-aop、starter-data-redis 的依賴

複製程式碼

 1 <dependencies>
 2     <dependency>
 3         <groupId>org.springframework.boot</groupId>
 4         <artifactId>spring-boot-starter-web</artifactId>
 5     </dependency>
 6     <dependency>
 7         <groupId>org.springframework.boot</groupId>
 8         <artifactId>spring-boot-starter-aop</artifactId>
 9     </dependency>
10     <dependency>
11         <groupId>org.springframework.boot</groupId>
12         <artifactId>spring-boot-starter-data-redis</artifactId>
13     </dependency>
14 </dependencies>

複製程式碼

二、屬性配置

在 application.properites 資原始檔中新增 redis 相關的配置項

spring.redis.host=192.168.68.110
spring.redis.port=6379
spring.redis.password=123456

三、註解

1、建立一個 CacheLock 註解，屬性配置如下

  • prefix： 快取中 key 的字首
  • expire： 過期時間，此處預設為 5 秒
  • timeUnit： 超時單位，此處預設為秒
  • delimiter： key 的分隔符，將不同引數值分割開來

複製程式碼

 1 import java.lang.annotation.*;
 2 import java.util.concurrent.TimeUnit;
 3 
 4 /**
 5  * 鎖的註解
 6  */
 7 @Target(ElementType.METHOD)
 8 @Retention(RetentionPolicy.RUNTIME)
 9 @Documented
10 @Inherited
11 public @interface CacheLock {
12 
13     /**
14      * redis 鎖key的字首
15      *
16      * @return redis 鎖key的字首
17      */
18     String prefix() default "";
19 
20     /**
21      * 過期秒數,預設為5秒
22      *
23      * @return 輪詢鎖的時間
24      */
25     int expire() default 5;
26 
27     /**
28      * 超時時間單位
29      *
30      * @return 秒
31      */
32     TimeUnit timeUnit() default TimeUnit.SECONDS;
33 
34     /**
35      * <p>Key的分隔符（預設 :）</p>
36      * <p>生成的Key：N:SO1008:500</p>
37      *
38      * @return String
39      */
40     String delimiter() default ":";
41 }

複製程式碼

2、 key 的生成規則是自己定義的，如果通過表示式語法自己得去寫解析規則還是比較麻煩的，所以依舊是用註解的方式

複製程式碼

 1 import java.lang.annotation.*;
 2 
 3 /**
 4  * 鎖的引數
 5  *
 6  */
 7 @Target({ElementType.PARAMETER, ElementType.METHOD, ElementType.FIELD})
 8 @Retention(RetentionPolicy.RUNTIME)
 9 @Documented
10 @Inherited
11 public @interface CacheParam {
12 
13     /**
14      * 欄位名稱
15      *
16      * @return String
17      */
18     String name() default "";
19 }

複製程式碼

四、Key生成策略

1、介面

複製程式碼

 1 import org.aspectj.lang.ProceedingJoinPoint;
 2 
 3 /**
 4  * key生成器
 5  */
 6 public interface CacheKeyGenerator {
 7 
 8     /**
 9      * 獲取AOP引數,生成指定快取Key
10      *
11      * @param pjp PJP
12      * @return 快取KEY
13      */
14     String getLockKey(ProceedingJoinPoint pjp);
15 }

複製程式碼

2、介面實現

複製程式碼

import com.carry.annotation.CacheLock;
import com.carry.annotation.CacheParam;
import com.carry.common.CacheKeyGenerator;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

/**
 * 通過介面注入的方式去寫不同的生成規則;
 */
public class LockKeyGenerator implements CacheKeyGenerator {

    @Override
    public String getLockKey(ProceedingJoinPoint pjp) {
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        Method method = signature.getMethod();
        CacheLock lockAnnotation = method.getAnnotation(CacheLock.class);
        final Object[] args = pjp.getArgs();
        final Parameter[] parameters = method.getParameters();
        StringBuilder builder = new StringBuilder();
        //預設解析方法裡面帶 CacheParam 註解的屬性,如果沒有嘗試著解析實體物件中的
        for (int i = 0; i < parameters.length; i++) {
            final CacheParam annotation = parameters[i].getAnnotation(CacheParam.class);
            if (annotation == null) {
                continue;
            }
            builder.append(lockAnnotation.delimiter()).append(args[i]);
        }
        if (StringUtils.isEmpty(builder.toString())) {
            final Annotation[][] parameterAnnotations = method.getParameterAnnotations();
            for (int i = 0; i < parameterAnnotations.length; i++) {
                final Object object = args[i];
                final Field[] fields = object.getClass().getDeclaredFields();
                for (Field field : fields) {
                    final CacheParam annotation = field.getAnnotation(CacheParam.class);
                    if (annotation == null) {
                        continue;
                    }
                    field.setAccessible(true);
                    builder.append(lockAnnotation.delimiter()).append(ReflectionUtils.getField(field, object));
                }
            }
        }
        return lockAnnotation.prefix() + builder.toString();
    }
}

複製程式碼

五、Lock攔截器（AOP）

熟悉 Redis 的朋友都知道它是執行緒安全的，我們利用它的特性可以很輕鬆的實現一個分散式鎖，如 opsForValue().setIfAbsent(key,value)它的作用就是如果快取中沒有當前 Key 則進行快取同時返回 true 反之亦然；當快取後給 key 在設定個過期時間，防止因為系統崩潰而導致鎖遲遲不釋放形成死鎖； 那麼我們是不是可以這樣認為當返回 true 我們認為它獲取到鎖了，在鎖未釋放的時候我們進行異常的丟擲….

複製程式碼

 1 import com.carry.annotation.CacheLock;
 2 import com.carry.common.CacheKeyGenerator;
 3 import org.aspectj.lang.ProceedingJoinPoint;
 4 import org.aspectj.lang.annotation.Around;
 5 import org.aspectj.lang.annotation.Aspect;
 6 import org.aspectj.lang.reflect.MethodSignature;
 7 import org.springframework.beans.factory.annotation.Autowired;
 8 import org.springframework.context.annotation.Configuration;
 9 import org.springframework.data.redis.core.StringRedisTemplate;
10 import org.springframework.util.StringUtils;
11 
12 import java.lang.reflect.Method;
13 
14 /**
15  * redis 方案
16  */
17 @Aspect
18 @Configuration
19 public class LockMethodInterceptor {
20 
21     @Autowired
22     public LockMethodInterceptor(StringRedisTemplate lockRedisTemplate, CacheKeyGenerator cacheKeyGenerator) {
23         this.lockRedisTemplate = lockRedisTemplate;
24         this.cacheKeyGenerator = cacheKeyGenerator;
25     }
26 
27     private final StringRedisTemplate lockRedisTemplate;
28     private final CacheKeyGenerator cacheKeyGenerator;
29 
30 
31     @Around("execution(public * *(..)) && @annotation(com.carry.annotation.CacheLock)")
32     public Object interceptor(ProceedingJoinPoint pjp) {
33         MethodSignature signature = (MethodSignature) pjp.getSignature();
34         Method method = signature.getMethod();
35         CacheLock lock = method.getAnnotation(CacheLock.class);
36         if (StringUtils.isEmpty(lock.prefix())) {
37             throw new RuntimeException("lock key can't be null...");
38         }
39         final String lockKey = cacheKeyGenerator.getLockKey(pjp);
40         try {
41             //key不存在才能設定成功
42             final Boolean success = lockRedisTemplate.opsForValue().setIfAbsent(lockKey, "");
43             if (success) {
44                 lockRedisTemplate.expire(lockKey, lock.expire(), lock.timeUnit());
45             } else {
46                 //按理來說 我們應該丟擲一個自定義的 CacheLockException 異常;
47                 throw new RuntimeException("請勿重複請求");
48             }
49             try {
50                 return pjp.proceed();
51             } catch (Throwable throwable) {
52                 throw new RuntimeException("系統異常");
53             }
54         } finally {
55             //如果演示的話需要註釋該程式碼;實際應該放開
56             // lockRedisTemplate.delete(lockKey);
57         }
58     }
59 }

複製程式碼

六、控制層

在介面方法上新增 @CacheLock(prefix = "test")，然後動態的值可以加上@CacheParam；生成後的新 key 將被快取起來；（如：該介面 token = 1，那麼最終的 key 值為 test:1，如果多個條件則依次類推）

複製程式碼

 1 import com.carry.annotation.CacheLock;
 2 import com.carry.annotation.CacheParam;
 3 import org.springframework.web.bind.annotation.GetMapping;
 4 import org.springframework.web.bind.annotation.RequestParam;
 5 import org.springframework.web.bind.annotation.RestController;
 6 
 7 @RestController
 8 public class LockController {
 9 
10     @CacheLock(prefix = "test")
11     @GetMapping("/test")
12     public String query(@CacheParam(name = "token") @RequestParam String token) {
13         return "success - " + token;
14     }
15 
16 }

複製程式碼

七、主函式

需要注入前面定義好的 CacheKeyGenerator 介面具體實現…

複製程式碼

 1 import com.carry.common.CacheKeyGenerator;
 2 import com.carry.common.LockKeyGenerator;
 3 import org.springframework.boot.SpringApplication;
 4 import org.springframework.boot.autoconfigure.SpringBootApplication;
 5 import org.springframework.context.annotation.Bean;
 6 
 7 @SpringBootApplication
 8 public class SpringbootCacheRedislockApplication {
 9 
10     public static void main(String[] args) {
11         SpringApplication.run(SpringbootCacheRedislockApplication.class, args);
12     }
13 
14     @Bean
15     public CacheKeyGenerator cacheKeyGenerator() {
16         return new LockKeyGenerator();
17     }
18 }

複製程式碼

八、測試

第一次請求結果：

第二次請求結果：

等key過期了請求又恢復正常。

相關推薦

分散式鎖之redis鎖及實現

分散式鎖有幾種常用的實現方式：zookeeper、memcached、redis、mysql。這裡介紹一下redis的實現方式，並在最後附上了一個Demo小工具： 眾所周知，reids鎖是通過setnx + expire的方式實現的，setnx保證只有在key不存在時才能se

Netty遊戲伺服器實戰開發(8):利用redis或者zookeeper實現3pc分散式事務鎖（二）。支撐騰訊系列某手遊百萬級流量公測

導讀：在上篇文章中介紹了分散式事務專案的基本原理和工程元件，我們瞭解到了分散式事務的理論知識。處於實戰的經驗，我們將理論知識使用到實際專案中。所以我們將藉助idea中maven工程 來實戰我們的專案。 回到正文： 在上篇文章中我們已經把需要的準備工作做好了。現在

分散式的redis鎖

    springboot2本地鎖實踐一文中提到用Guava Cache實現鎖機制，但在叢集中就行不通了，所以我們還一般要藉助類似Redis、ZooKeeper 之類的中介軟體實現分散式鎖，下面我們將利用自定義註解、Spring Aop、Redis Cache 實現分散

高併發場景系列(一) 利用redis實現分散式事務鎖,解決高併發環境下減庫存

問題描述:某電商平臺,首發一款新品手機,每人限購2臺,預計會有10W的併發,在該情況下,如果扣減庫存,保證不會超賣 方案一 利用資料庫鎖機制,對記錄進行鎖定,再進行操作  SELECT * from goods where ID =1 for updat

Redis分散式事務鎖實現

Redis事務鎖 在不同程序需要互斥地訪問共享資源時，分散式鎖是一種非常有用的技術手段。本文采用Spring Data Redis實現一下Redis的分散式事務鎖。 Redis為單程序單執行緒模式，採用佇列模式將併發訪問變成序列訪問，且多客戶端對Redis的

SpringCloud定時任務需要用redis實現分散式全域性鎖的相關操作

      我們知道現在微服務很流行,為此,許多中小型企業都將自己以前的框架加以改造,其中以SpringCloud為最多,但是SpringCloud如果要加定時任務的話,在單臺伺服器上很好支援,但是涉及到叢集服務(多臺服務的話)就要用到分散式鎖了,最簡單的方案是用R

關於redis 鎖(分散式鎖)的問題

首先,工作中的redis是從阿里獲取的資源，工作需求有搶紅包和簽到的功能需求，這時就難免出現併發，因而涉及到鎖的問題，網上搜了搜相關知識 不少是用setnx和getset實現，例如：http://blog.csdn.net/ugg/article/details/41894

利用redis實現分散式事務鎖,解決高併發環境下減庫存

http://download.redis.io/releases/ 安裝： sudo make test 測試編譯 sudo make install 啟動： redis-servre cd “安裝目錄” redis-server ./redis-3.2.9/redis

基於Redis RedLock的分散式同步鎖

本文采用Redis官網提供的RedLock來實現分散式同步鎖，實現了單機模式和哨兵叢集模式兩種。 安全和可靠性保證 在描述我們的設計之前，我們想先提出三個屬性，這三個屬性在我們看來，是實現高效分散式鎖的基礎。 安全屬性：互斥，不管任何時候，只有一個客戶端能持有

分散式Redis的分散式鎖 Redlock

連結 Distributed locks with Redis 引言 之前自己在用redis來實現分散式鎖的時候都是基於單個Redis例項，也就是說Redis本身是有單點故障的，Redis的官方文件介紹了一種"自認為"合理的演算法，Redlock來實現分散式Redis下的分散式鎖。 M

通過Expire實現Redis鎖機制

在我們的業務系統中,可能因為某種原因,使用者會不斷的點選表單提交按鈕,為了較少對系統的 無意義訪問、暴力提交 以及使用者體驗,我們利用redis的過期時間簡單的實現了一種Redis鎖 當用戶提交表單的時候,我們通過對錶單資料以及使用者唯一標識例如userNo進行加密,當做我們快取的唯

Redis鎖機制處理高併發

文章正文   這裡我們主要利用Redis的setnx的命令來處理高併發。 setnx 有兩個引數。第一個引數表示鍵。第二個引數表示值。如果當前鍵不存在，那麼會插入當前鍵，將第二個引數做為值。返回 1。如果當前鍵存在，那麼會返回0。 建立庫存表 CREATE T

zk 分散式共享鎖小Demo

public class DistributedClientLock {          // 會話超時     private static final int SESSION_TIMEOUT = 2

利用Redis鎖解決併發問題

轉發 https://blog.csdn.net/fuyifang/article/details/83008884 用redis處理高併發是個很常見的方式，因為redis的訪問效率很高（直接訪問記憶體），一般我們會用來處理網站一瞬間的併發量。 那如果要使用redis來進行高併發問

.net core 下的分散式事務鎖

目錄 系統分散式鎖的用法 鎖的實現 鎖的使用 API內的範例： 引用連結 系統分散式鎖的用法 公司框架新增功能分散式鎖： 鎖的效能之王： 快取 > Zooke

簡單基本的 redis 鎖

 這個比較簡單的實現，不過也可以用的 之後考慮用lua指令碼實現 /** * 嘗試獲取簡單鎖 * 這裡簡單的鎖 不考慮併發 * 待擴充套件為 單條redis執行原子鎖 SETNX + EXPIRE * @param lockKey 鎖key * @param expire

定時任務redis鎖+自定義lambda優化提取冗餘程式碼

功能介紹： 我係統中需要跑三個定時任務，由於是多節點部署，為了防止多個節點的定時任務重複執行。所以在定時任務執行時加個鎖，搶到鎖的節點才能執行定時任務，沒有搶到鎖的節點就不執行。從而避免了定時任務重複執行的情況 沒有使用lambda表示式時的程式碼是這樣的： 　　@Scheduled(cron

分散式Redis的使用

參考自這篇文章，作者寫的很棒。 作者：孤獨煙 來自：http://rjzheng.cnblogs.com/     1.為什麼使用Redis 　　專案中使用Redis，主要從兩個角度考慮：效能和併發。Redis還可以做分散式等其他功能，但是如果只是為了做分散式鎖還可以考慮其他中

分散式redis 中的哨兵模式

設定的哨兵模式和其他redis伺服器相同，只不過不能做儲存等處理 哨兵也是 Redis 伺服器，只是它與我們平時提到的 Redis 伺服器職能不同，哨兵負責監視普通的 Redis 伺服器，提高一個伺服器叢集的健壯和可靠性。哨兵和普通的 Redis 伺服器所用的是同一套伺服器框架，這包括：網路框架，

分散式共享鎖的程式邏輯流程

有時根據需求，幾臺伺服器需要從一個WEB介面或者資料庫獲得同樣的資源，因為不能同時獲取，就涉及到了資源排程演算法   一種資源排程邏輯是： 1.程式節點啟動時到zookeeper上註冊一個“臨時+序號”的znode，並監聽父節點。 2.獲取父節點下所有的程式子節點，比較序號的大小。 3.序