關於Redis分散式鎖這一篇應該是講的最好的了，先收藏起來再看！

前程有光發表於2020-12-10

Redis分散式

前言

在Java併發程式設計中，我們通常使用到synchronized 、Lock這兩個執行緒鎖，Java中的鎖，只能保證對同一個JVM中的執行緒有效。而在分散式叢集環境，這個時候我們就需要使用到分散式鎖。

實現分散式鎖的方案

基於資料庫實現分散式鎖
基於快取Redis實現分散式鎖
基於Zookeeper的臨時序列化節點實現分散式鎖

Redis實現分散式鎖

場景：在高併發的情況下，可能有大量請求來到資料庫查詢三級分類資料，而這種資料不會經常改變，可以引入快取來儲存第一次從資料庫查詢出來的資料，其他執行緒就可以去快取中獲取資料，來減少資料庫的查詢壓力。

在叢集的環境下，就可以使用分散式鎖來控制去查詢資料庫的次數。

階段一

    private  Map<String, List<Catelog2Vo>>  getCatalogJsonDBWithRedisLock() {
        // 去Redis中搶佔位置
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "1111");
        if (lock){
            // 搶到鎖了 執行業務
            Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
            // 刪除鎖
            stringRedisTemplate.delete("lock");
            return dataFromDb;
        }else {
            // 自旋獲取鎖
            // 休眠100ms
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return getCatalogJsonDBWithRedisLock();
        }
    }

得到鎖以後，我們應該再去快取中確定一次，如果沒有才需要繼續查詢，從資料庫查到資料以後，應該先把資料放入快取中，再將資料返回。

  private Map<String, List<Catelog2Vo>> getDataFromDb() {
        // 得到鎖以後，我們應該再去快取中確定一次，如果沒有才需要繼續查詢
        String catalogJson = stringRedisTemplate.opsForValue().get("catalogJson");
        if (!StringUtils.isEmpty(catalogJson)) {
            // 反序列化 轉換為指定物件
            Map<String, List<Catelog2Vo>> result = JSON.parseObject(catalogJson, new 
            TypeReference<Map<String, List<Catelog2Vo>>>() {});
            return result;
        }
        System.out.println("查詢資料庫了......");
        // 查詢所有分類資料在進行刷選
        List<CategoryEntity> categoryEntityList = baseMapper.selectList(null);
        // 查詢一級分類
        List<CategoryEntity> leave1Categorys = getParent_cid(categoryEntityList, 0L);
        Map<String, List<Catelog2Vo>> listMap = leave1Categorys.stream().collect(Collectors.toMap(k -> k.getCatId().toString(), l1 -> {

            List<CategoryEntity> categoryL2List = getParent_cid(categoryEntityList, l1.getCatId());
            List<Catelog2Vo> catelog2Vos = null;
            if (categoryL2List != null) {
                catelog2Vos = categoryL2List.stream().map(l2 -> {
                    Catelog2Vo catelog2Vo = new Catelog2Vo(l2.getParentCid().toString(), null, l2.getCatId().toString(), l2.getName());

                    List<CategoryEntity> categoryL3List = getParent_cid(categoryEntityList, 
                                                                        l2.getCatId());
                    if (categoryL3List != null) {
                        List<Catelog2Vo.Catelog3Vo> catelog3Vos =  
                            categoryL3List.stream().map(l3 -> {
                            Catelog2Vo.Catelog3Vo catelog3Vo = new 
                               Catelog2Vo.Catelog3Vo(l2.getCatId().toString(), 
                                                      l3.getCatId().toString(), 
                                                      l3.getName());
                            return catelog3Vo;
                        }).collect(Collectors.toList());
                        catelog2Vo.setCatalog3List(catelog3Vos);
                    }
                    return catelog2Vo;
                }).collect(Collectors.toList());
            }
            return catelog2Vos;
        }));
        // 最後需將資料加入的快取中
        String jsonString = JSON.toJSONString(listMap);
        stringRedisTemplate.opsForValue().set("catalogJson", jsonString, 1L, 
                                              TimeUnit.DAYS);

        return listMap;
    }

階段二

    private  Map<String, List<Catelog2Vo>>  getCatalogJsonDBWithRedisLock() {
        // 去Redis中搶佔位置
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", "1111");
        if (lock){
            // 搶到鎖了 執行業務
            // 設定過期時間
            stringRedisTemplate.expire("lock",3,TimeUnit.SECONDS);
            Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
            // 刪除鎖
            stringRedisTemplate.delete("lock");
            return dataFromDb;
        }else {
            // 自旋獲取鎖
            // 休眠100ms
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return getCatalogJsonDBWithRedisLock();
        }
    }

階段三

  private  Map<String, List<Catelog2Vo>>  getCatalogJsonDBWithRedisLock() {
        // 去Redis中搶佔位置  保證原子性
      Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", 
      "1111",300,TimeUnit.SECONDS);
        if (lock){
            // 搶到鎖了 執行業務
            Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
            // 刪除鎖
            stringRedisTemplate.delete("lock");
            return dataFromDb;
        }else {
            // 自旋獲取鎖
            // 休眠100ms
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return getCatalogJsonDBWithRedisLock();
        }
    }

階段四

private  Map<String, List<Catelog2Vo>>  getCatalogJsonDBWithRedisLock() {
        String uuid = UUID.randomUUID().toString();
        // 去Redis中搶佔位置  保證原子性
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid,300,TimeUnit.SECONDS);
        if (lock){
            // 搶到鎖了 執行業務
            Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
            String s = stringRedisTemplate.opsForValue().get("lock");
            if (uuid.equals(s)){
                // 刪除鎖
                stringRedisTemplate.delete("lock");
            }
            return dataFromDb;
        }else {
            // 自旋獲取鎖
            // 休眠100ms
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return getCatalogJsonDBWithRedisLock();
        }
    }

階段五

  private  Map<String, List<Catelog2Vo>>  getCatalogJsonDBWithRedisLock() {
        String uuid = UUID.randomUUID().toString();
        // 去Redis中搶佔位置  保證原子性
        Boolean lock = stringRedisTemplate.opsForValue().setIfAbsent("lock", uuid,300,TimeUnit.SECONDS);
        if (lock){
            // 搶到鎖了 執行業務
            Map<String, List<Catelog2Vo>> dataFromDb = getDataFromDb();
            String s = stringRedisTemplate.opsForValue().get("lock");
            // 獲取值對比+對比成功刪除=原子操作 Lua指令碼解鎖
            String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1] then\n" +
                    "    return redis.call(\"del\",KEYS[1])\n" +
                    "else\n" +
                    "    return 0\n" +
                    "end";
            Long lock1 = stringRedisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class) , Arrays.asList("lock"), uuid);
            return dataFromDb;
        }else {
            // 自旋獲取鎖
            // 休眠100ms
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return getCatalogJsonDBWithRedisLock();
        }
    }

小總結

stringRedisTemplate.opsForValue().setIfAbsent(“lock”, uuid,300,TimeUnit.SECONDS);
stringRedisTemplate.execute(new DefaultRedisScript(script, Long.class) , Arrays.asList(“lock”), uuid);
使用Redis來實現分散式鎖需保證加鎖【佔位+過期時間】和刪除鎖【判斷+刪除】操作的原子性。
Redis鎖的過期時間小於業務的執行時間該如何自動續期？
- 設定一個比業務耗時更長的過期時間
- Redisson的看門狗機制

Redisson實現分散式鎖

Redisson 簡介

Redisson是一個在Redis的基礎上實現的Java駐記憶體資料網格（In-Memory Data Grid）。它不僅提供了一系列的分散式的Java常用物件，還提供了許多分散式服務。其中包括(BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson提供了使用Redis的最簡單和最便捷的方法。Redisson的宗旨是促進使用者對Redis的關注分離（Separation of Concern），從而讓使用者能夠將精力更集中地放在處理業務邏輯上。

原理機制

整合Spring Boot 專案

引入依賴【可引入Spring Boot 封裝好的starter】

  <!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.12.0</version>
        </dependency>

新增配置類

@Configuration
public class MyRedissonConfig {

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient(){
        // 建立配置  記得加redis://
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.26.104:6379");
        // 根據配置建立RedissClient客戶端
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }
}

可重入鎖 Reentrant Lock

獲取一把鎖 redissonClient.getLock(“my-lock”);
給業務程式碼加鎖 lock.lock();
解鎖 lock.unlock();
看門狗機制鎖會自動續期

@ResponseBody
    @GetMapping("/hello")
    public String hello(){
        // 1、獲取一把鎖，只要鎖的名字一樣，就是同一把鎖
        RLock lock = redissonClient.getLock("my-lock");
        // 加鎖
        // 阻塞式等待，預設加的鎖都是【看門狗時間】30s時間
        //1)、鎖的自動續期，如果業務超長，執行期間自動給鎖續上新的30s，不用擔心業務時間長，鎖自動過期被刪掉
        //2)、加鎖的業務只要執行完成，就不會給當前鎖續期，即使不手動解鎖，鎖預設在30s以後自動刪除
        lock.lock();
        try {
            System.out.println("加鎖成功......."+Thread.currentThread().getId());
            Thread.sleep(30000);
        } catch (InterruptedException e) {

        }finally {
            // 釋放鎖   不會出現死鎖狀態 如果沒有執行解鎖，鎖有過期時間，過期了會將鎖刪除
            lock.unlock();
            System.out.println("解鎖成功......"+Thread.currentThread().getId());
        }
        return "hello";
    }

lock方法有一個過載方法 lock(long leaseTime, TimeUnit unit)

  public void lock(long leaseTime, TimeUnit unit) {
        try {
            this.lock(leaseTime, unit, false);
        } catch (InterruptedException var5) {
            throw new IllegalStateException();
        }
    }

注意：指定了過期時間後，不會進行自動續期，此時如果有多個執行緒，即便業務還然在執行，過期時間到了之後，鎖就會被釋放，其他執行緒就會爭搶到鎖。

二個方法對比

如果設定了過期時間，就會發生執行指令碼給Redis，進行佔鎖，設定過期時間為我們指定的時間。
未設定過期時間，就會使用看門狗的預設時間LockWatchdogTimeout 30*1000
只有沒有指定過期的時間的方法才有自動續期功能
自動續期實現機制：只要佔鎖成功，就會自動啟動一個定時任務【重新給鎖設定過期時間，新的過期時間就是看門狗的預設時間】，每隔10s【（ internalLockLeasTime）/3】都會自動續期。
持有鎖的機器當機問題，因為來不及續期，所以鎖自動被釋放，當該機再次恢復時，因為其後臺守護執行緒是ScheduleTask，所以恢復後會馬上執行一次watchDog續期邏輯，執行過程中，它會感知到自己已經丟失了鎖，所以不存在共同持有的問題。

讀寫鎖 ReadWriteLock

保證一定能讀到最新資料，修改期間，寫鎖是一個互斥鎖，讀鎖是一個共享鎖。

寫+讀寫鎖沒有釋放，讀鎖就得等待
寫+寫阻塞方式
讀+寫寫鎖等待讀鎖釋放才能加鎖
讀+讀相當於無鎖，併發讀

 @ResponseBody
    @GetMapping("/write")
    public String writeLock(){
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("rw-lock");
        RLock rLock = readWriteLock.writeLock();
        String s = "";
        try {
            rLock.lock();
            System.out.println("寫鎖加鎖成功......"+Thread.currentThread().getId());
            s = UUID.randomUUID().toString();
            stringRedisTemplate.opsForValue().set("writeLock",s);
            Thread.sleep(30000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            rLock.unlock();
            System.out.println("寫鎖釋放成功......"+Thread.currentThread().getId());
        }
       return s;
    }

    @ResponseBody
    @GetMapping("/read")
    public String readLock(){
        RReadWriteLock readWriteLock = redissonClient.getReadWriteLock("rw-lock");
        RLock rLock = readWriteLock.readLock();
        rLock.lock();
        String s = "";
        try{
            System.out.println("讀鎖加鎖成功......"+Thread.currentThread().getId());
            s = stringRedisTemplate.opsForValue().get("writeLock");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            System.out.println("讀鎖釋放成功......"+Thread.currentThread().getId());
            rLock.unlock();
        }
        return s;
    }

訊號量 Semaphore

使用訊號量來做分散式限流

    @ResponseBody
    @GetMapping("/park")
    public String park() throws InterruptedException {
        RSemaphore park = redissonClient.getSemaphore("park");
        // 搶佔一個車位
        boolean b = park.tryAcquire();
        // 如果還可以搶佔到 就執行業務程式碼
        if (b){
            // 執行業務程式碼
        }else {
            return "error";
        }
        return "ok=>"+b;
    }

    @ResponseBody
    @GetMapping("/go")
    public String go() {
        RSemaphore park = redissonClient.getSemaphore("park");
        //  釋放一個車位
        park.release();
        return "ok";
    }

閉鎖 CountDownLatch

模擬場景：等待班級放學走了，保安關校門。

    @ResponseBody
    @GetMapping("/lockdoor")
    public String lockDoor() throws InterruptedException {
        RCountDownLatch door = redissonClient.getCountDownLatch("door");
        door.trySetCount(5);
        // 等待閉鎖完成
        door.await();
        return "放假了.....";
    }

    @GetMapping("/gogogo/{id}")
    @ResponseBody
    public String gogogo(@PathVariable("id")Long id){
        RCountDownLatch door = redissonClient.getCountDownLatch("door");
        // 計數減一
        door.countDown();
        return id+"班級走了....";
    }

Redisson解決上面Redis查詢問題

  /**
     * 使用Redisson分散式鎖來實現多個服務共享同一快取中的資料
     * @return
     */
    private Map<String, List<Catelog2Vo>> getCatalogJsonDBWithRedissonLock() {
        RLock lock = redissonClient.getLock("catalogJson-lock");
         // 該方法會阻塞其他執行緒向下執行，只有釋放鎖之後才會接著向下執行
        lock.lock();
        Map<String, List<Catelog2Vo>> dataFromDb = null;
        try {
            dataFromDb = getDataFromDb();
        }finally {
            lock.unlock();
        }
        return dataFromDb;
    }

最後

歡迎關注公眾號：前程有光，領取一線大廠Java面試題總結+各知識點學習思維導+一份300頁pdf文件的Java核心知識點總結！

基於 Redis 的分散式鎖
2018-04-02
Redis分散式
基於redis的分散式鎖
2018-06-28
Redis分散式
關於分散式鎖原理的一些學習與思考-redis分散式鎖，zookeeper分散式鎖
2019-05-22
分散式Redis
基於 Redis 分散式鎖
2022-04-15
Redis分散式
Redis 應用-分散式鎖
2019-07-05
Redis分散式
[翻譯]基於redis的分散式鎖
2018-12-02
Redis分散式
基於redis的分散式鎖實現
2018-01-06
Redis分散式
來了解一下Redis的分散式鎖
2018-02-19
Redis分散式
基於redis做分散式鎖
2024-03-11
Redis分散式
一種redis命令搞定基於redis的分散式鎖
2017-09-12
Redis分散式
基於 Redis 的分散式鎖到底安全嗎？
2017-02-27
Redis分散式
十九、Redis分散式鎖、Zookeeper分散式鎖
2019-01-02
Redis分散式
基於redis實現分散式鎖
2018-11-19
Redis分散式
基於Redis的分散式鎖的簡單實現
2018-01-27
Redis分散式
基於 Redis 實現簡單的分散式鎖
2016-05-21
Redis分散式
【劍指Offer】Redis 分散式鎖的實現原理看這篇就夠了
2020-09-26
Redis分散式
Redis分散式鎖這樣用，有坑？
2023-04-16
Redis分散式
Redis Redisson 分散式鎖的應用和原始碼
2021-10-20
Redis分散式原始碼
分散式鎖-Redis
2018-12-04
分散式Redis
redis 分散式鎖
2020-09-01
Redis分散式
Redis分散式鎖
2024-04-26
Redis分散式
redis分散式鎖的實現
2023-02-23
Redis分散式
基於Redis分散式BitMap的應用
2022-03-04
Redis分散式
基於Redis分散式鎖的正確開啟方式
2020-07-16
Redis分散式
[轉載]基於Redis的分散式鎖到底安全嗎？
2019-02-24
Redis分散式
java 實現開箱即用基於 redis 的分散式鎖
2022-12-14
JavaRedis分散式
基於redis和zookeeper的分散式鎖實現方式
2018-06-15
Redis分散式
Redis 分散式鎖（一）
2020-07-16
Redis分散式
Redis分散式鎖解析
2019-03-23
Redis分散式
redis系列：分散式鎖
2018-08-15
Redis分散式
redis分散式鎖-可重入鎖
2021-05-24
Redis分散式
Redis分散式鎖加鎖案例
2021-12-17
Redis分散式
關於 JavaScript 中的特殊函式，你應該這樣看
2020-10-26
JavaScript函式
Golang 基於單節點 Redis 實現的分散式鎖
2020-07-05
GolangRedis分散式
高併發架構系列：分散式鎖的由來、特點及Redis分散式鎖的實現詳解
2018-12-20
架構分散式Redis
【分散式鎖的演化】什麼是鎖？
2020-12-14
分散式
基於redis分散式鎖實現“秒殺”
2019-01-29
Redis分散式
基於Redis實現一個分散式鎖
2021-11-14
Redis分散式