在.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 = 10;
public async Task<bool> BuyAsync()
{
    // 模拟执行的逻辑代码花费的时间
    await Task.Delay(new Random().Next(100, 500));
    if (stockCount > 0)
    {
        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 <= 0)
                {
                    throw new ArgumentException("RedisUrl 不能为空");
                }
                var endPoints = new List<RedLockEndPoint>();
                foreach (var item in redisUrls)
                {
                    var arr = item.Split(":");
                    endPoints.Add(new DnsEndPoint(arr[0], Convert.ToInt32(arr[1])));
                }
                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(5), TimeSpan.FromSeconds(1), TimeSpan.FromMilliseconds(20)))
    {
        if (redLock.IsAcquired)
        {
            var result = await _productService.BuyAsync();
            return result;
        }
        else
        {
            Console.WriteLine($"获取锁失败：{DateTime.Now}");
        }
    }
    return false;
}

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