成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

掌握微服務下分布式鎖的正確姿勢

開發 前端 分布式
分布式鎖是控制分布式系統之間同步訪問共享資源的一種方式。在分布式系統中,常常需要協調他們的動作。

[[391029]]

前言

在Java中,我們對于鎖會比較熟悉,常用的有 synchronized、Lock鎖,在java并發編程中,我們通過鎖,來實現當多個線程競爭同一個共享資源或者變量而造成的數據不一致的問題,但是JVM鎖只能針對于單個應用服務,隨著我們業務的發展需要,單體單機部署的系統早已演化成分布式系統,由于分布式系統的多線程、多進程而且分布在不同的機器上,這個時候JVM鎖的并發控制就沒有效果了,為了解決跨JVM鎖并且能夠控制共享資源的訪問,于是有了分布式鎖的誕生。


什么是分布式鎖

分布式鎖是控制分布式系統之間同步訪問共享資源的一種方式。在分布式系統中,常常需要協調他們的動作。如果不同的系統或是同一個系統的不同主機之間共享了一個或一組資源,那么訪問這些資源的時候,往往需要互斥來防止彼此干擾來保證一致性,在這種情況下,便需要使用到分布式鎖

為什么JVM鎖在分布式下不可以呢?

我們通過代碼來看一下就知道,為什么集群下jvm鎖是不可靠的呢?我們模擬一下商品搶購的場景,A服務有十個用戶去搶購這個商品,B服務有十個用戶去搶購這個商品,當有其中一個用戶搶購成功后,其他用戶不可以在對這個商品進行下單操作,那么到底是A服務會搶到還是B服務會搶到這個商品呢,我們來看一下

當其中有一個用戶搶購成功后,status會變成1


GrabService:

  1. public interface GrabService { 
  2.  
  3.     /** 
  4.      * 商品搶單 
  5.      * @param orderId 
  6.      * @param driverId 
  7.      * @return 
  8.      */ 
  9.     public ResponseResult grabOrder(int orderId, int driverId); 

GrabJvmLockServiceImpl:

  1. @Service("grabJvmLockService"
  2. public class GrabJvmLockServiceImpl implements GrabService { 
  3.  
  4.   @Autowired 
  5.   OrderService orderService; 
  6.  
  7.   @Override 
  8.   public ResponseResult grabOrder(int orderId, int driverId) { 
  9.     String lock = (orderId+""); 
  10.  
  11.     synchronized (lock.intern()) { 
  12.       try { 
  13.         System.out.println("用戶:"+driverId+" 執行下單邏輯"); 
  14.  
  15.               boolean b = orderService.grab(orderId, driverId); 
  16.               if(b) { 
  17.                 System.out.println("用戶:"+driverId+" 下單成功"); 
  18.               }else { 
  19.                 System.out.println("用戶:"+driverId+" 下單失敗"); 
  20.               } 
  21.           } finally { 
  22.  
  23.           } 
  24.     } 
  25.     return null
  26.   } 

OrderService :

  1. public interface OrderService { 
  2.   public boolean grab(int orderId, int driverId); 

OrderServiceImpl :

  1. @Service 
  2. public class OrderServiceImpl implements OrderService { 
  3.  
  4.   @Autowired 
  5.   private OrderMapper mapper; 
  6.  
  7.   public boolean grab(int orderId, int driverId) { 
  8.     Order order = mapper.selectByPrimaryKey(orderId); 
  9.      try { 
  10.              Thread.sleep(1000); 
  11.          } catch (InterruptedException e) { 
  12.              e.printStackTrace(); 
  13.          } 
  14.     if(order.getStatus().intValue() == 0) { 
  15.       order.setStatus(1); 
  16.       mapper.updateByPrimaryKeySelective(order); 
  17.  
  18.       return true
  19.     } 
  20.     return false
  21.  
  22.   } 

這里我們模擬集群環境,啟動兩個端口,8004和8005進行訪問這里我們用jmeter進行測試如果不會jmeter的可以看我之前對tomcat進行壓測的文章:tomcat優化

項目啟動順序:先啟動 Server-eureka注冊中心、在啟動 8004和8005端口

測試結果:


這里我們可以看到 8004 服務和 8005 服務 同時都有一個用戶去下單成功這個商品,但是這個商品只能有一個用戶能夠去搶到,因此jvm鎖如果是在集群或分布式下,是無法保證訪問共享變量的數據同時只有一個線程訪問的,無法解決分布式,集群環境的問題。所以需要使用到分布鎖。

分布式鎖三種實現方式

分布式鎖的實現方式總共有三種:

  • 基于數據庫實現分布式鎖
  • 基于緩存(Redis)實現分布式鎖
  • 基于Zookeeper實現分布式鎖今天,我們主要講的是基于Redis實現的分布式鎖

reids實現分布式鎖有三種方式

1、基于redis的 SETNX 實現分布式鎖

2、Redisson實現分布式鎖

3、使用redLock實現分布式鎖

目錄結構:


方式一:基于 SETNX 實現分布式鎖

將key的值設為value ,當且僅當key不存在。若給定的key已經存在,則SETNX不做任何動作。setnx:當key存在,不做任何操作,key不存在,才設置

加鎖:

  1. SET orderId driverId NX PX 30000 
  2. 上面的命令如果執行成功,則客戶端成功獲取到了鎖,接下來就可以訪問共享資源了;而如果上面的命令執行失敗,則說明獲取鎖失敗。 

釋放鎖:關鍵,判斷是不是自己加的鎖。

GrabService :

  1. public interface GrabService { 
  2.  
  3.     /** 
  4.      * 商品搶單 
  5.      * @param orderId 
  6.      * @param driverId 
  7.      * @return 
  8.      */ 
  9.     public ResponseResult grabOrder(int orderId, int driverId); 

GrabRedisLockServiceImpl :

  1. @Service("grabRedisLockService"
  2. public class GrabRedisLockServiceImpl implements GrabService { 
  3.  
  4.   @Autowired 
  5.   StringRedisTemplate stringRedisTemplate; 
  6.  
  7.   @Autowired 
  8.   OrderService orderService; 
  9.  
  10.     @Override 
  11.     public ResponseResult grabOrder(int orderId , int driverId){ 
  12.         //生成key 
  13.       String lock = "order_"+(orderId+""); 
  14.       /* 
  15.        *  情況一,如果鎖沒執行到釋放,比如業務邏輯執行一半,運維重啟服務,或 服務器掛了,沒走 finally,怎么辦? 
  16.        *  加超時時間 
  17.        */ 
  18. //      boolean lockStatus = stringRedisTemplate.opsForValue().setIfAbsent(lock.intern(), driverId+""); 
  19. //      if(!lockStatus) { 
  20. //        return null
  21. //      } 
  22.  
  23.       /* 
  24.        *  情況二:加超時時間,會有加不上的情況,運維重啟 
  25.        */ 
  26. //      boolean lockStatus = stringRedisTemplate.opsForValue().setIfAbsent(lock.intern(), driverId+""); 
  27. //      stringRedisTemplate.expire(lock.intern(), 30L, TimeUnit.SECONDS); 
  28. //      if(!lockStatus) { 
  29. //        return null
  30. //      } 
  31.  
  32.       /* 
  33.        * 情況三:超時時間應該一次加,不應該分2行代碼, 
  34.        *  
  35.        */ 
  36.       boolean lockStatus = stringRedisTemplate.opsForValue().setIfAbsent(lock.intern(), driverId+"", 30L, TimeUnit.SECONDS); 
  37.       if(!lockStatus) { 
  38.         return null
  39.       } 
  40.  
  41.       try { 
  42.       System.out.println("用戶:"+driverId+" 執行搶單邏輯"); 
  43.  
  44.             boolean b = orderService.grab(orderId, driverId); 
  45.             if(b) { 
  46.               System.out.println("用戶:"+driverId+" 搶單成功"); 
  47.             }else { 
  48.               System.out.println("用戶:"+driverId+" 搶單失敗"); 
  49.             } 
  50.  
  51.         } finally { 
  52.           /** 
  53.            * 這種釋放鎖有,可能釋放了別人的鎖。 
  54.            */ 
  55. //          stringRedisTemplate.delete(lock.intern()); 
  56.  
  57.           /** 
  58.            * 下面代碼避免釋放別人的鎖 
  59.            */ 
  60.           if((driverId+"").equals(stringRedisTemplate.opsForValue().get(lock.intern()))) { 
  61.             stringRedisTemplate.delete(lock.intern()); 
  62.           } 
  63.         } 
  64.         return null
  65.     } 

這里可能會有人問,如果我業務的執行時間超過了鎖釋放的時間,會怎么辦呢?我們可以使用守護線程,只要我們當前線程還持有這個鎖,到了10S的時候,守護線程會自動對該線程進行加時操作,會續上30S的過期時間,直到把鎖釋放,就不會在進行續約了,開啟一個子線程,原來時間是N,每隔N/3,在去續上N

關注點:

  1. key,是我們的要鎖的目標,比如訂單ID。
  2. driverId 是由我們的商品ID,它要保證在足夠長的一段時間內在所有客戶端的所有獲取鎖的請求中都是唯一的。即一個訂單被一個用戶搶。
  3. NX表示只有當orderId不存在的時候才能SET成功。這保證了只有第一個請求的客戶端才能獲得鎖,而其它客戶端在鎖被釋放之前都無法獲得鎖。
  4. PX 30000表示這個鎖有一個30秒的自動過期時間。當然,這里30秒只是一個例子,客戶端可以選擇合適的過期時間。
  5. 這個鎖必須要設置一個過期時間。 否則的話,當一個客戶端獲取鎖成功之后,假如它崩潰了,或者由于發生了網絡分區,導致它再也無法和Redis節點通信了,那么它就會一直持有這個鎖,而其它客戶端永遠無法獲得鎖了。antirez在后面的分析中也特別強調了這一點,而且把這個過期時間稱為鎖的有效時間(lock validity time)。獲得鎖的客戶端必須在這個時間之內完成對共享資源的訪問。
  6. 此操作不能分割。>SETNX orderId driverId EXPIRE orderId 30 雖然這兩個命令和前面算法描述中的一個SET命令執行效果相同,但卻不是原子的。如果客戶端在執行完SETNX后崩潰了,那么就沒有機會執行EXPIRE了,導致它一直持有這個鎖。造成死鎖。

方式二:基于redisson實現分布式鎖

流程圖:


代碼實現:

  1. @Service("grabRedisRedissonService"
  2. public class GrabRedisRedissonServiceImpl implements GrabService { 
  3.  
  4.   @Autowired 
  5.   RedissonClient redissonClient; 
  6.  
  7.   @Autowired 
  8.   OrderService orderService; 
  9.  
  10.     @Override 
  11.     public ResponseResult grabOrder(int orderId , int driverId){ 
  12.         //生成key 
  13.       String lock = "order_"+(orderId+""); 
  14.  
  15.       RLock rlock = redissonClient.getLock(lock.intern()); 
  16.  
  17.  
  18.       try { 
  19.         // 此代碼默認 設置key 超時時間30秒,過10秒,再延時 
  20.         rlock.lock(); 
  21.       System.out.println("用戶:"+driverId+" 執行搶單邏輯"); 
  22.  
  23.             boolean b = orderService.grab(orderId, driverId); 
  24.             if(b) { 
  25.               System.out.println("用戶:"+driverId+" 搶單成功"); 
  26.             }else { 
  27.               System.out.println("用戶:"+driverId+" 搶單失敗"); 
  28.             } 
  29.  
  30.         } finally { 
  31.           rlock.unlock(); 
  32.         } 
  33.         return null
  34.     } 

關注點:

1.redis故障問題。如果redis故障了,所有客戶端無法獲取鎖,服務變得不可用。為了提高可用性。我們給redis 配置主從。當master不可用時,系統切換到slave,由于Redis的主從復制(replication)是異步的,這可能導致喪失鎖的安全性

  • 1.客戶端1從Master獲取了鎖。2.Master宕機了,存儲鎖的key還沒有來得及同步到Slave上。3.Slave升級為Master。4.客戶端2從新的Master獲取到了對應同一個資源的鎖。

客戶端1和客戶端2同時持有了同一個資源的鎖。鎖的安全性被打破。

2.鎖的有效時間(lock validity time),設置成多少合適?如果設置太短的話,鎖就有可能在客戶端完成對于共享資源的訪問之前過期,從而失去保護;如果設置太長的話,一旦某個持有鎖的客戶端釋放鎖失敗,那么就會導致所有其它客戶端都無法獲取鎖,從而長時間內無法正常工作。應該設置稍微短一些,如果線程持有鎖,開啟線程自動延長有效期

方式三:基于RedLock實現分布式鎖

針對于以上兩點,antirez設計了Redlock算法 Redis的作者antirez給出了一個更好的實現,稱為Redlock,算是Redis官方對于實現分布式鎖的指導規范。Redlock的算法描述就放在Redis的官網上:https://redis.io/topics/distlock

目的:對共享資源做互斥訪問

因此antirez提出了新的分布式鎖的算法Redlock,它基于N個完全獨立的Redis節點(通常情況下N可以設置成5),意思就是N個Redis數據不互通,類似于幾個陌生人

代碼實現:

  1. @Service("grabRedisRedissonRedLockLockService"
  2. public class GrabRedisRedissonRedLockLockServiceImpl implements GrabService { 
  3.  
  4.     @Autowired 
  5.     private RedissonClient redissonRed1; 
  6.     @Autowired 
  7.     private RedissonClient redissonRed2; 
  8.     @Autowired 
  9.     private RedissonClient redissonRed3; 
  10.  
  11.     @Autowired 
  12.     OrderService orderService; 
  13.  
  14.     @Override 
  15.     public ResponseResult grabOrder(int orderId , int driverId){ 
  16.         //生成key 
  17.         String lockKey = (RedisKeyConstant.GRAB_LOCK_ORDER_KEY_PRE + orderId).intern(); 
  18.         //紅鎖 
  19.         RLock rLock1 = redissonRed1.getLock(lockKey); 
  20.         RLock rLock2 = redissonRed2.getLock(lockKey); 
  21.         RLock rLock3 = redissonRed2.getLock(lockKey); 
  22.         RedissonRedLock rLock = new RedissonRedLock(rLock1,rLock2,rLock3); 
  23.  
  24.         try { 
  25.            rLock.lock(); 
  26.         // 此代碼默認 設置key 超時時間30秒,過10秒,再延時 
  27.       System.out.println("用戶:"+driverId+" 執行搶單邏輯"); 
  28.  
  29.             boolean b = orderService.grab(orderId, driverId); 
  30.             if(b) { 
  31.               System.out.println("用戶:"+driverId+" 搶單成功"); 
  32.             }else { 
  33.               System.out.println("用戶:"+driverId+" 搶單失敗"); 
  34.             } 
  35.  
  36.         } finally { 
  37.           rLock.unlock(); 
  38.         } 
  39.         return null
  40.     } 

 

運行Redlock算法的客戶端依次執行下面各個步驟,來完成 獲取鎖 的操作:

  1. 獲取當前時間(毫秒數)。
  2. 按順序依次向N個Redis節點執行 獲取鎖 的操作。這個獲取操作跟前面基于單Redis節點的 獲取鎖 的過程相同,包含value driverId ,也包含過期時間(比如 PX30000 ,即鎖的有效時間)。為了保證在某個Redis節點不可用的時候算法能夠繼續運行,這個 獲取鎖 的操作還有一個超時時間(time out),它要遠小于鎖的有效時間(幾十毫秒量級)。
  3. 客戶端在向某個Redis節點獲取鎖失敗以后,應該立即嘗試下一個Redis節點。這里的失敗,應該包含任何類型的失敗,比如該Redis節點不可用,或者該Redis節點上的鎖已經被其它客戶端持有
  4. 計算整個獲取鎖的過程總共消耗了多長時間,計算方法是用當前時間減去第1步記錄的時間。如果客戶端從大多數Redis節點(>= N/2+1)成功獲取到了鎖,比如:五臺機器如果加鎖成功三臺就默認加鎖成功,并且獲取鎖總共消耗的時間沒有超過鎖的有效時間(lock validity time),那么這時客戶端才認為最終獲取鎖成功;否則,認為最終獲取鎖失敗
  5. 如果最終獲取鎖成功了,那么這個鎖的有效時間應該重新計算,它等于最初的鎖的有效時間減去第3步計算出來的獲取鎖消耗的時間。
  6. 如果最終獲取鎖失敗了(可能由于獲取到鎖的Redis節點個數少于N/2+1,或者整個獲取鎖的過程消耗的時間超過了鎖的最初有效時間),那么客戶端應該立即向所有Redis節點發起 釋放鎖 的操作(即前面介紹的Redis Lua腳本)。上面描述的只是 獲取鎖 的過程,而 釋放鎖 的過程比較簡單:客戶端向所有Redis節點發起 釋放鎖 的操作,不管這些節點當時在獲取鎖的時候成功與否。

總結

到這里redis分布式鎖就講完了,具體使用哪一種類型的分布式鎖需要看公司業務的,流量大的可以使用RedLock實現分布式鎖,流量小的可以使用redisson,后面會講解Zookeeper實現分布式鎖。

 

責任編輯:姜華 來源: 牧小農
相關推薦

2021-03-07 16:11:26

Redis分布式

2017-03-14 11:52:52

微服務架構數據管理

2022-05-18 10:38:51

Redis分布式鎖數據

2019-06-19 15:40:06

分布式鎖RedisJava

2021-09-28 09:43:11

微服務架構技術

2022-04-14 08:51:49

微服務Redisson分布式鎖

2019-05-24 14:45:17

分布式微服務運維

2012-02-28 10:30:56

C#.NET

2023-09-12 22:58:51

分布式架構微服務

2023-11-20 15:32:29

2023-12-19 22:19:21

軟件架構開發架構

2017-10-24 11:28:23

Zookeeper分布式鎖架構

2024-11-28 15:11:28

2018-07-17 08:14:22

分布式分布式鎖方位

2022-08-04 08:45:50

Redisson分布式鎖工具

2019-02-26 09:51:52

分布式鎖RedisZookeeper

2021-07-16 07:57:34

ZooKeeperCurator源碼

2023-05-29 14:07:00

Zuul網關系統

2018-11-27 16:17:13

分布式Tomcat
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板: 一区二区成人 | 日韩高清成人 | 亚洲不卡在线观看 | 久久久久久免费精品一区二区三区 | 久久久久久国产精品 | 免费成人高清 | 日韩一区二区三区视频在线播放 | 在线免费观看黄色 | 日本精品在线一区 | 亚洲精品久久视频 | 亚洲免费人成在线视频观看 | 亚洲一区二区三区四区视频 | 激情网站 | 久久国产免费看 | 国产一在线观看 | 精品一区二区三区免费视频 | 亚洲成人av| 亚洲综合小视频 | 久久久久久久久久久国产 | 成人在线视频一区 | 国产激情视频 | 深夜福利亚洲 | 精品综合 | 懂色av一区二区三区在线播放 | 涩涩鲁亚洲精品一区二区 | 日产精品久久久一区二区福利 | 特级做a爰片毛片免费看108 | 欧美日韩综合精品 | 欧美三区 | 久久久.com| 亚洲黄色一区二区三区 | 亚洲一区二区三区在线观看免费 | 色婷婷亚洲一区二区三区 | 久久国产一区二区三区 | 欧美日韩亚洲国产 | 日韩黄色免费 | 免费看国产一级特黄aaaa大片 | 9久久精品 | 国产精品久久av | 在线日韩中文字幕 | 欧美精品在线免费观看 |