利用分布式锁在ASP.NET Core中实现防抖

惠宇五金

前言

在 Web 应用开发过程中，防抖（Debounce） 是确保同一操作在短时间内不会被重复触发的一种有效手段。常见的场景包括防止用户在短时间内重复提交表单，或者避免多次点击按钮导致后台服务执行多次相同的操作。无论在单机环境中，还是在分布式系统中都有一些场景需要使用它。本文将介绍如何在ASP.NET Core中通过使用锁的方式来实现防抖，从而保证无论在单个或多实例部署的情况下都能有效避免重复操作。
分布式锁接口定义

要实现分布式锁的第一步是定义一个通用的锁接口。通过 IDistributedLock 接口，应用程序可以在不同的场景中选择使用不同类型的锁来实现。

1. public interface IDistributedLock
2. {
3.     /// <summary>
4.     /// 尝试获取分布式锁。
5.     /// </summary>
6.     /// <param name="resourceKey">要锁定的资源标识。</param>
7.     /// <param name="lockDuration">锁的持续时间。</param>
8.     /// <returns>是否成功获取锁。</returns>
9.     Task<bool> TryAcquireLockAsync(string resourceKey, TimeSpan? lockDuration = null);
11.     /// <summary>
12.     /// 释放分布式锁。
13.     /// </summary>
14.     /// <param name="resourceKey">要释放的资源标识。</param>
15.     Task ReleaseLockAsync(string resourceKey);
16. }

复制代码

这个接口定义了两个核心方法：

• TryAcquireLockAsync：尝试获取分布式锁。如果锁获取成功，则返回 true，否则返回 false。
  
• ReleaseLockAsync：释放已获取的锁，允许其他操作进入临界区。
  

Redis 版本的分布式锁实现

在日常开发的方案中，Redis 是一个常见的分布式锁实现方式。通过 Redis 的原子操作配合SETNX指令，可以确保在多个实例环境中只有一个实例能够获取到锁。下面是 Redis 版本的分布式锁实现代码。

1. public class RedisDistributedLock : IDistributedLock
2. {
3.     private readonly ConnectionMultiplexer _redisConnection;
4.     private IDatabase _database;
6.     public RedisDistributedLock(ConnectionMultiplexer redisConnection)
7.     {
8.         _redisConnection = redisConnection;
9.         _database = _redisConnection.GetDatabase();
10.     }
12.     public Task<bool> TryAcquireLockAsync(string resourceKey, TimeSpan? lockDuration = null)
13.     {
14.         var isLockAcquired = _database.StringSetAsync(resourceKey, 1, lockDuration, When.NotExists);
15.         return isLockAcquired;
16.     }
18.     public Task ReleaseLockAsync(string resourceKey)
19.     {
20.         return _database.KeyDeleteAsync(resourceKey);
21.     }
22. }

复制代码

在这个实现中使用的是StackExchange.Redis的SDK，当然大家可以自行选择合适的库来实现，主要是演示起来方便，因为其他库需要用脚本自行实现可过期的SETNX：

• 我们使用了 ConnectionMultiplexer 来管理与 Redis 的连接。
  
• TryAcquireLockAsync 方法使用了 StringSetAsync 方法，其中 When.NotExists 参数确保只有在键不存在时才能成功设置值，从而实现锁的功能。
  
• ReleaseLockAsync 方法简单地删除了锁对应的键，从而释放锁。
  

如果你选用其它Redis的SDK，一般需要写脚本来实现可以过期的SETNX，可以参考下面的LUA脚本

1. -- 参数: KEYS[1] 表示键，ARGV[1] 表示值，ARGV[2] 表示过期时间（秒）
2. if redis.call("SETNX", KEYS[1], ARGV[1]) == 1 then
3.     redis.call("EXPIRE", KEYS[1], ARGV[2])
4.     return 1
5. else
6.     return 0
7. end

复制代码

• 使用 SETNX 尝试设置键 KEYS[1] 的值为 ARGV[1]。如果键不存在，则返回 1 并成功设置键；如果键已存在，则返回 0。
  
• 如果 SETNX 返回 1，则为该键设置过期时间，过期时间为 ARGV[2] 秒。
  
• 最终脚本返回 1 表示成功设置了键值对并设置了过期时间，返回 0 表示键已经存在，操作未成功。
  

本地锁的实现

在某些情况下，例如单机或单体应用中，使用本地锁可能会更为合适。这个时候使用基于内存的本地锁实现效果可能会更好。有的同学可能会担心请求量的问题，导致内存占用过高的问题。其实换个角度考虑，如果有很大请求量或并发量，大多数我们可能不会直接使用单机。好了我们继续来看，这里我们为了方便，直接使用ConcurrentDictionary来实现。

1. public class LocalLock : IDistributedLock
2. {
3.     private readonly ConcurrentDictionary<string, byte> lockCounts = new ConcurrentDictionary<string, byte>();
5.     public Task<bool> TryAcquireLockAsync(string resourceKey, TimeSpan? lockDuration = null)
6.     {
7.         byte lockCount = 0;
9.         if (lockCounts.TryAdd(resourceKey, lockCount))
10.         {
11.             lockCounts[resourceKey] = 1;
12.             return Task.FromResult(true);
13.         }
14.         return Task.FromResult(false);
15.     }
17.     public Task ReleaseLockAsync(string resourceKey)
18.     {
19.         lockCounts.TryRemove(resourceKey, out _);
20.         return Task.CompletedTask;
21.     }
22. }

复制代码

在这个实现中：

• 我们使用 ConcurrentDictionary 来管理锁的状态，确保线程安全。
  
• TryAcquireLockAsync 方法尝试在字典中添加一个键，如果成功则表示获取锁成功。
  
• ReleaseLockAsync 方法从字典中移除对应的键，从而释放锁。
  

其实如果C#提供ConcurrentHashSet的话，用ConcurrentHashSet来实现会更好一点。毕竟ConcurrentDictionary是KV的方式来是实现，每个Value都会浪费一定的内存空间。当然你也可以选择自行实现一套ConcurrentHashSet，需要注意的是实现的时候尽量使用桶锁，避免使用全局锁。

防抖过滤器的实现

接下来我们使用上面定义的IDistributedLock和Filter来实现防抖过滤器，我们创建一个基于 IAsyncActionFilter 接口实现的过滤器，更方便我们在请求执行前后获取和释放锁操作。

1. public class DistributedLockFilterAttribute : Attribute, IAsyncActionFilter
2. {
3.     private readonly string _lockPrefix;
4.     private readonly LockType _lockType;
6.     public DistributedLockFilterAttribute(string keyPrefix, LockType lockType = LockType.Local)
7.     {
8.         _lockPrefix = keyPrefix;
9.         _lockType = lockType;
10.     }
12.     public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
13.     {
14.         IDistributedLock distributedLock = context.HttpContext.RequestServices.GetRequiredKeyedService<IDistributedLock>(_lockType.GetDescription());
16.         string controllerName = context.RouteData.Values["controller"]?.ToString() ?? "";
17.         string actionName = context.RouteData.Values["action"]?.ToString() ?? "";
18.         //用户信息或其他唯一标识都可
19.         var userKey = context.HttpContext.User!.Identity!.Name;
21.         string lockKey = $"{_lockPrefix}:{userKey}:{controllerName}_{actionName}";
22.         bool isLockAcquired = await distributedLock.TryAcquireLockAsync(lockKey);
23.         
24.         if (!isLockAcquired)
25.         {
26.             context.Result = new ObjectResult(new { code = 400, message = "请不要重复操作" });
27.             return;
28.         }
30.         try
31.         {
32.             await next();
33.         }
34.         finally
35.         {
36.             await distributedLock.ReleaseLockAsync(lockKey);
37.         }
38.     }
39. }

复制代码

在这个过滤器的操作中：

• 我们通过容器和LockType获取具体的分布式锁实现。
  
• 使用 controllerName 和 actionName 以及用户标识构(或其他唯一标识)建锁的键，确保锁的唯一性。
  
• 如果获取锁失败，则直接返回错误响应，避免后续操作的执行。
  
• 在操作执行完毕后，无论是否成功，都释放锁。
  

为了更灵活地在不同的锁实现之间进行切换，我们定义了一个枚举 LockType，通过扩展方法 GetDescription 获取其描述，方便我们使用它的值。

1. public enum LockType
2. {
3.     [Description("redis")]
4.     Redis,
5.     [Description("local")]
6.     Local
7. }
9. public static class EnumExtensions
10. {
11.     public static string GetDescription(this Enum @enum)
12.     {
13.         Type type = @enum.GetType();
14.         string name = Enum.GetName(type, @enum);
15.         if (name == null)
16.         {
17.             return null;
18.         }
20.         FieldInfo field = type.GetField(name);
21.         DescriptionAttribute attribute = System.Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
23.         if (attribute == null)
24.         {
25.             return name;
26.         }
27.         return attribute?.Description;
28.     }
29. }

复制代码

这个扩展方法可以更方便地根据枚举的类型获取对应的枚举描述，从而在依赖注入中灵活的选择不同锁的实现，如果有更好的实现方式也可以，我们尽量使用更容易懂的方式。
注册和使用过滤器

在ASP.NET Core中，我们可以通过依赖注入的方式注册分布式锁相关的服务，并在控制器操作中应用防抖过滤器的功能，以下是注册和使用分布式锁的示例代码。

1. builder.Services.AddSingleton<ConnectionMultiplexer>(_ => ConnectionMultiplexer.Connect(builder.Configuration["Redis:ConnectionString"]!));
2. //给IDistributedLock添加不同的实现
3. builder.Services.AddKeyedSingleton<IDistributedLock, RedisDistributedLock>(LockType.Redis.GetDescription());
4. builder.Services.AddKeyedSingleton<IDistributedLock, LocalLock>(LockType.Local.GetDescription());

复制代码

在这里，我们注册了 Redis 和本地两种分布式锁实现，并使用键（key）区分它们，以便在运行时根据需要选择具体的锁类型。
接下来，在控制器的操作方法上应用我们定义的 DistributedLockFilter 过滤器，用来实现Action的防抖功能。

1. [HttpGet("GetCurrentTime")]
2. [DistributedLockFilter("GetCurrentTime", LockType.Redis)]
3. public async Task<string> GetCurrentTime()
4. {
5.     await Task.Delay(10000); // 模拟长时间操作
6.     return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
7. }

复制代码

在这个简单的示例中：

• DistributedLockFilter 过滤器确保了当用户请求 GetCurrentTime 操作时，不会在短时间内重复触发相同的操作。
  
• 锁的类型被设置为 LockType.Redis，因此在分布式环境下，多个实例之间也可以共享这个锁，当然这个类型是可选的。
  

如果是在10s之内连续多次请求则会返回如下错误

1. {
2.   "code": 400,
3.   "message": "请不要重复操作"
4. }

复制代码

总结

本文详细介绍了如何在 ASP.NET Core 中使用分布式锁实现防抖功能。通过定义通用的 IDistributedLock 接口，我们可以实现不同类型的锁机制，包括 Redis 和本地内存锁。Redis 锁利用其原子操作确保分布式环境中的唯一性，而本地锁则适用于单机环境。通过创建 DistributedLockFilter 过滤器，我们将锁机制集成到 ASP.NET Core 控制器中，防止对Action进行重复操作。
这种方法不仅提高了应用的稳定性，也增强了用户体验，避免了短时间内重复操作的问题。希望本文对大家有所帮助。如果有任何问题或进一步讨论的需求，欢迎在评论区留言。


  
来源:https://www.cnblogs.com/wucy/p/18394437/aspnetcore-distributed-lock-debounce
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！