C# 使用StackExchange.Redis实现分布式锁的两种方式

分布式锁在集群的架构中发挥着重要的作用。以下有主要的使用场景
1.在秒杀、抢购等高并发场景下，多个用户同时下单同一商品，可能导致库存超卖。
2.支付、转账等金融操作需保证同一账户的资金变动是串行执行的。
3.分布式环境下，多个节点可能同时触发同一任务（如定时报表生成）。
4.用户因网络延迟重复提交表单，可能导致数据重复插入。

目录

• 自定义分布式锁
  
  
  
  • 获取锁
    
  • 释放锁
    
  • 自动续期
    
  
  
• StackExchange.Redis分布式锁
  
  
  
  • 获取锁
    
  • 释放锁
    
  • 自动续期
    
  
  

自定义分布式锁

获取锁

比如一下一个场景，需要对订单号为 order-88888944010的订单进行扣款处理，因为后端是多节点的，防止出现用户重复点击导致扣款请求到不用的集群节点，所以需要同时只有一个节点处理该订单。

1.         public static async Task<(bool Success, string LockValue)> LockAsync(string cacheKey, int timeoutSeconds = 5)
2.         {
3.             var lockKey = GetLockKey(cacheKey);
4.             var lockValue = Guid.NewGuid().ToString();
5.             var timeoutMilliseconds = timeoutSeconds * 1000;
6.             var expiration = TimeSpan.FromMilliseconds(timeoutMilliseconds);
7.             bool flag = await _redisDb.StringSetAsync(lockKey, lockValue, expiration, When.NotExists);
9.             return (flag, flag ? lockValue : string.Empty);
10.         }

复制代码

1.         public static string GetLockKey(string cacheKey)
2.         {
3.             return $"MyApplication:locker:{cacheKey}";
4.         }

复制代码

上述代码是在请求时将订单号作为redis key的一部分存储到redis中，并且生成了一个随机的lockValue作为值。只有当redis中不存在该key的时候才能够成功设置，即为获取到该订单的分布式锁了。

1.             await LockAsync("order-88888944010",30); //获取锁，并且设置超时时间为30秒

复制代码

释放锁

1.         public static async Task<bool> UnLockAsync(string cacheKey, string lockValue)
2.         {
3.             var lockKey = GetLockKey(cacheKey);
4.             var script = @"local invalue = @value
5.                                     local currvalue = redis.call('get',@key)
6.                                     if(invalue==currvalue) then redis.call('del',@key)
7.                                         return 1
8.                                     else
9.                                         return 0
10.                                     end";
11.             var parameters = new { key = lockKey, value = lockValue };
12.             var prepared = LuaScript.Prepare(script);
13.             var result = (int)await _redisDb.ScriptEvaluateAsync(prepared, parameters);
15.             return result == 1;
16.         }

复制代码

释放锁采用了lua脚本先判断lockValue是否是同一个处理节点发过来的删除请求，即判断加锁和释放锁是同一个来源。
用lua脚本而不是直接使用API执行删除的原因:

1.A获取锁后因GC停顿或网络延迟导致锁过期，此时客户端B获取了锁。若A恢复后直接调用DEL，会错误删除B持有的锁。
2.脚本在Redis中单线程执行，确保GET和DEL之间不会被其他命令打断。

自动续期

一些比较耗时的任务，可能在指定的超时时间内无法完成业务处理，需要存在自动续期的机制。

1.         /// <summary>
2.         /// 自动续期
3.         /// </summary>
4.         /// <param name="redisDb"></param>
5.         /// <param name="key"></param>
6.         /// <param name="value"></param>
7.         /// <param name="milliseconds">续期的时间</param>
8.         /// <returns></returns>
9.         public async static Task Delay(IDatabase redisDb, string key, string value, int milliseconds)
10.         {
11.             if (!AutoDelayHandler.Instance.ContainsKey(key))
12.                 return;
14.             var script = @"local val = redis.call('GET', @key)
15.                                     if val==@value then
16.                                         redis.call('PEXPIRE', @key, @milliseconds)
17.                                         return 1
18.                                     end
19.                                     return 0";
20.             object parameters = new { key, value, milliseconds };
21.             var prepared = LuaScript.Prepare(script);
22.             var result = await redisDb.ScriptEvaluateAsync(prepared, parameters, CommandFlags.None);
23.             if ((int)result == 0)
24.             {
25.                 AutoDelayHandler.Instance.CloseTask(key);
26.             }
27.             return;
28.         }

复制代码

保存自动续期任务的处理器

1. public class AutoDelayHandler
2. {
3.      private static readonly Lazy lazy = new Lazy(() => new AutoDelayHandler());
4.      private static ConcurrentDictionary<string, (Task, CancellationTokenSource)> _tasks = new ConcurrentDictionary<string, (Task, CancellationTokenSource)>();
6.      public static AutoDelayHandler Instance => lazy.Value;
8.      /// <summary>
9.      /// 任务令牌添加到集合中
10.      /// </summary>
11.      /// <param name="key"></param>
12.      /// <param name="task"></param>
13.      /// <returns></returns>
14.      public bool TryAdd(string key, Task task, CancellationTokenSource token)
15.      {
16.          if (_tasks.TryAdd(key, (task, token)))
17.          {
18.              task.Start();
20.              return true;
21.          }
22.          else
23.          {
24.              return false;
25.          }
26.      }
29.      public void CloseTask(string key)
30.      {
31.          if (_tasks.ContainsKey(key))
32.          {
33.              if (_tasks.TryRemove(key, out (Task, CancellationTokenSource) item))
34.              {
35.                  item.Item2?.Cancel();
36.                  item.Item1?.Dispose();
37.              }
38.          }
39.      }
41.      public bool ContainsKey(string key)
42.      {
43.          return _tasks.ContainsKey(key);
44.      }
45. }

复制代码

在申请带有自动续期的分布式锁的完整代码

1. /// <summary>
2. /// 获取锁
3. /// </summary>
4. /// <param name="cacheKey"></param>
5. /// <param name="timeoutSeconds">超时时间</param>
6. /// <param name="autoDelay">是否自动续期</param>
7. /// <returns></returns>
8. public static async Task<(bool Success, string LockValue)> LockAsync(string cacheKey, int timeoutSeconds = 5, bool autoDelay = false)
9. {
10.     var lockKey = GetLockKey(cacheKey);
11.     var lockValue = Guid.NewGuid().ToString();
12.     var timeoutMilliseconds = timeoutSeconds * 1000;
13.     var expiration = TimeSpan.FromMilliseconds(timeoutMilliseconds);
14.     bool flag = await _redisDb.StringSetAsync(lockKey, lockValue, expiration, When.NotExists);
15.     if (flag && autoDelay)
16.     {
17.         //需要自动续期，创建后台任务
18.         CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
19.         var autoDelaytask = new Task(async () =>
20.         {
21.             while (!cancellationTokenSource.IsCancellationRequested)
22.             {
23.                 await Task.Delay(timeoutMilliseconds / 2);
24.                 await Delay(lockKey, lockValue, timeoutMilliseconds);
25.             }
26.         }, cancellationTokenSource.Token);
27.         var result = AutoDelayHandler.Instance.TryAdd(lockKey, autoDelaytask, cancellationTokenSource);
29.         if (!result)
30.         {
31.             autoDelaytask.Dispose();
32.             await UnLockAsync(cacheKey, lockValue);
33.             return (false, string.Empty);
34.         }
35.     }
36.     return (flag, flag ? lockValue : string.Empty);
37. }

复制代码

<blockquote>
Redis的过期时间精度约为1秒，且过期检查是周期性执行的（默认每秒10次）。选择TTL/2的间隔能：
确保在Redis下一次过期检查前完成续期。
兼容Redis的主从同步延迟（通常