DistributedLock 实现方式.Net分布式锁功能实用指南

作者：袖梨 2026-09-01

平时做技术实践时，很多问题不是概念不会，而是细节没串起来。拿“DistributedLock 实现方法.Net分布式锁功能”来说，它看着像小点，放到项目里常会牵出环境、配置、兼容性和维护成本。下面按实际采用顺序，把思路、关键写法和容易踩坑的地方讲清楚，便于大家直接对照操作。

什么是 DistributedLock

在这个场景下，DistributedLock 是一个轻量级、线程安全的 .NET 库，用来在分布式环境下实现锁的功能。兼容多种后端存储，包括：

Redis
SQL Server
PostgreSQL
MySQL
MongoDB
内存模式（本地锁）

只需更换存储提供程序，就能无缝地在不同的环境下采用。

基本采用

安装 NuGet 包

在项目里引入需的后端依赖，如：

dotnet add package DistributedLock  --包含所有实现的元包
dotnet add package DistributedLock.Redis
dotnet add package DistributedLock.SqlServer

结合项目来看，（Redis 和 SQL Server 是最常用的场景，也能够选择别的实现）

采用 Redis 分布式锁

  var RedisConnectionString = "localhost:6379,abortConnect=false";
  var LockName = "MyResourceLock";
  var connection = await ConnectionMultiplexer.ConnectAsync(RedisConnectionString); // uses StackExchange.Redis
  var @lock = new RedisDistributedLock(LockName, connection.GetDatabase());
  await using (var handle = await @lock.TryAcquireAsync())
  {
      if (handle != null) { /* I have the lock */ }
  }

结合项目来看，只要采用 Acquire / AcquireAsync 拿到锁，代码块执行完毕后会自动释放，很优雅。

采用 SQL Server 分布式锁

using Medallion.Threading.SqlServer;
using System;
using System.Threading;
using System.Threading.Tasks;
namespace DistributedLockDemo
{
    internal class Program
    {
        static async Task Main(string[] args)
        {
            var connectionString = "Server=myServerAddress;Database=Locks;User Id=myUsername;Password=myPassword;";
            var lockName = "MyResourceLock";
            // 创建分布式锁对象（不需要 using，因为它不实现 IDisposable）
            var sqlLock = new SqlDistributedLock(lockName, connectionString);
            // 尝试获取锁，返回的锁句柄（LockHandle）实现了 IDisposable
            using (var lockHandle = sqlLock.TryAcquire(TimeSpan.FromSeconds(30)))
            {
                if (lockHandle != null) // 判断是否成功获取锁
                {
                    // 持有锁，执行需要同步的代码
                    Console.WriteLine("Lock acquired, performing operation...");
                    // 模拟业务操作
                    await Task.Delay(1000); // 建议使用异步延迟而非 Thread.Sleep
                }
                else
                {
                    Console.WriteLine("Failed to acquire lock within the timeout.");
                }
            } // 此处会自动释放锁（lockHandle.Dispose()）
        }
    }
}

在 定时任务（Quartz、Hangfire 等） 场景中，特别适合用来避免多节点重复执行。

依赖注入集成

appsettings.json

{
  "ConnectionStrings": {
    "SqlServer": "Server=myServerAddress;Database=Locks;User Id=myUsername;Password=myPassword;",
    "Redis": "localhost:6379"
  }
}

DistributedLock 兼容依赖注入，适合在项目里采用。

// Startup.cs 或 Program.cs
public void ConfigureServices(IServiceCollection services)
{
    var connectionString = Configuration.GetConnectionString("SqlServer");
    services.AddSingleton<IDistributedLockProvider>(_ => 
        new SqlDistributedSynchronizationProvider(connectionString));
    services.AddTransient<SomeService>();
}
// SomeService.cs
public class SomeService
{
    private readonly IDistributedLockProvider _lockProvider;
    public SomeService(IDistributedLockProvider lockProvider)
    {
        _lockProvider = lockProvider;
    }
    public async Task InitializeUserAccountAsync(int id)
    {
        var @lock = _lockProvider.CreateLock(#34;UserAccount{id}");
        await using (await @lock.AcquireAsync())
        {
            // 执行需要同步的操作
            Console.WriteLine(#34;Initializing user account {id}...");
            await Task.Delay(1000);
        }
    }
}