在.Net中使用RedLock实现分布式锁

⒈简介

　　RedLock 分布式锁算法由 Redis 的作者提出，大部分语言都有对应的实现，查看，RedLock.net 是 RedLock 分布式锁算法的 .NET 版实现，用来解决分布式下的并发问题。

　　RedLock 的思想是使用多台 Redis Master ，节点之间完全独立，节点间不需要进行数据同步，因为 Master-Slave 架构一旦 Master 发生故障时数据没有复制到 Slave，被选为 Master 的 Slave 就丢掉了锁，另一个客户端就可以再次拿到锁。

　　锁通过 setNX（原子操作） 命令设置，在有效时间内当获得锁的数量大于 (n/2+1) 代表成功，失败后需要向所有节点发送释放锁的消息。

　　获取锁：

 SET resource_name my_random_value NX PX 30000

　　释放锁：

 if redis.call("get",KEYS[1]) == ARGV[1] then
     return redis.call("del",KEYS[1])
 else
     return 0
 end

⒉使用

　　1.创建 .NETCore API 项目

　　2.Nuget 安装 RedLock.net

 Install-Package RedLock.net

　　3.appsettings.json 添加 redis 配置

 {
   "Logging": {
     "LogLevel": {
       "Default": "Warning"
     }
   },
   "AllowedHosts": "*",
   "RedisUrls": [
     "127.0.0.1:6379",
     "192.168.214.128:6379"
   ]
 }

　　4.添加 ProductService.cs，模拟商品购买

 // 有10个商品库存，如果同时启动多个API服务进行测试，这里改成存数据库或其他方式
 private static int stockCount = ;
 public async Task<bool> BuyAsync()
 {
     // 模拟执行的逻辑代码花费的时间
     await Task.Delay(new Random().Next(, ));
     if (stockCount > )
     {
         stockCount--;
         return true;
     }
     return false;
 }

　　5.修改 Startup.cs ，创建 RedLockFactory

　　　　1.定义RedLockFactory属性

         private RedLockFactory lockFactory
         {
             get
             {
                 var redisUrls = Configuration.GetSection("RedisUrls").GetChildren().Select(s => s.Value).ToArray();
                 if(redisUrls.Length <= )
                 {
                     throw new ArgumentException("RedisUrl 不能为空");
                 }
                 var endPoints = new List<RedLockEndPoint>();
                 foreach (var item in redisUrls)
                 {
                     var arr = item.Split(":");
                     endPoints.Add(new DnsEndPoint(arr[], Convert.ToInt32(arr[])));
                 }
                 return RedLockFactory.Create(endPoints);
             }
         }

　　　　2.在 ConfigureServices 注入 IDistributedLockFactory：

         // This method gets called by the runtime. Use this method to add services to the container.
         public void ConfigureServices(IServiceCollection services)
         {
             services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
             services.AddSingleton(typeof(IDistributedLockFactory), lockFactory);
             services.AddScoped(typeof(ProductService));
         }

　　　　3.修改 Configure，应用程序结束时释放 lockFactory

         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
         public void Configure(IApplicationBuilder app, IHostingEnvironment env, IApplicationLifetime lifetime)
         {
             if (env.IsDevelopment())
             {
                 app.UseDeveloperExceptionPage();
             }

             app.UseMvc();

             lifetime.ApplicationStopping.Register(() =>
             {
                 lockFactory.Dispose();
             });

         }

　　6.在 Controller 添加方法 DistributedLockTest

 private readonly IDistributedLockFactory _distributedLockFactory;
 private readonly ProductService _productService;

 public HomeController(IDistributedLockFactory distributedLockFactory,
     ProductService productService)
 {
     _distributedLockFactory = distributedLockFactory;
     _productService = productService;
 }

 [HttpGet]
 public async Task<bool> DistributedLockTest()
 {
     var productId = "id";
     // resource 锁定的对象
     // expiryTime 锁定过期时间，锁区域内的逻辑执行如果超过过期时间，锁将被释放
     // waitTime 等待时间,相同的 resource 如果当前的锁被其他线程占用,最多等待时间
     // retryTime 等待时间内，多久尝试获取一次
     using (var redLock = await _distributedLockFactory.CreateLockAsync(productId, TimeSpan.FromSeconds(), TimeSpan.FromSeconds(), TimeSpan.FromMilliseconds()))
     {
         if (redLock.IsAcquired)
         {
             var result = await _productService.BuyAsync();
             return result;
         }
         else
         {
             Console.WriteLine($"获取锁失败：{DateTime.Now}");
         }
     }
     return false;
 }

　　在文章RedLock 实现分布式锁基础之上修改部分代码编写。