C#使用StackExchange.Redis實現(xiàn)分布式鎖的兩種方式介紹

更新時間：2025年04月27日 16:23:59 作者：BruceNeter

分布式鎖在集群的架構(gòu)中發(fā)揮著重要的作用,這篇文章主要為大家介紹了C#使用StackExchange.Redis實現(xiàn)分布式鎖的兩種方式,希望對大家有一定的幫助

自定義分布式鎖

獲取鎖

比如一下一個場景，需要對訂單號為 order-88888944010的訂單進行扣款處理，因為后端是多節(jié)點的，防止出現(xiàn)用戶重復(fù)點擊導(dǎo)致扣款請求到不用的集群節(jié)點，所以需要同時只有一個節(jié)點處理該訂單。

        public static async Task<(bool Success, string LockValue)> LockAsync(string cacheKey, int timeoutSeconds = 5)
        {
            var lockKey = GetLockKey(cacheKey);
            var lockValue = Guid.NewGuid().ToString();
            var timeoutMilliseconds = timeoutSeconds * 1000;
            var expiration = TimeSpan.FromMilliseconds(timeoutMilliseconds);
            bool flag = await _redisDb.StringSetAsync(lockKey, lockValue, expiration, When.NotExists);

            return (flag, flag ? lockValue : string.Empty);
        }

        public static string GetLockKey(string cacheKey)
        {
            return $"MyApplication:locker:{cacheKey}";
        }

上述代碼是在請求時將訂單號作為redis key的一部分存儲到redis中，并且生成了一個隨機的lockValue作為值。只有當(dāng)redis中不存在該key的時候才能夠成功設(shè)置，即為獲取到該訂單的分布式鎖了。

            await LockAsync("order-88888944010",30); //獲取鎖，并且設(shè)置超時時間為30秒

釋放鎖

        public static async Task<bool> UnLockAsync(string cacheKey, string lockValue)
        {
            var lockKey = GetLockKey(cacheKey);
            var script = @"local invalue = @value
                                    local currvalue = redis.call('get',@key)
                                    if(invalue==currvalue) then redis.call('del',@key)
                                        return 1
                                    else
                                        return 0
                                    end";
            var parameters = new { key = lockKey, value = lockValue };
            var prepared = LuaScript.Prepare(script);
            var result = (int)await _redisDb.ScriptEvaluateAsync(prepared, parameters);

            return result == 1;
        }

釋放鎖采用了lua腳本先判斷l(xiāng)ockValue是否是同一個處理節(jié)點發(fā)過來的刪除請求，即判斷加鎖和釋放鎖是同一個來源。

用lua腳本而不是直接使用API執(zhí)行刪除的原因:

1.A獲取鎖后因GC停頓或網(wǎng)絡(luò)延遲導(dǎo)致鎖過期，此時客戶端B獲取了鎖。若A恢復(fù)后直接調(diào)用DEL，會錯誤刪除B持有的鎖。

2.腳本在Redis中單線程執(zhí)行，確保GET和DEL之間不會被其他命令打斷。

自動續(xù)期

一些比較耗時的任務(wù)，可能在指定的超時時間內(nèi)無法完成業(yè)務(wù)處理，需要存在自動續(xù)期的機制。

        /// <summary>
        /// 自動續(xù)期
        /// </summary>
        /// <param name="redisDb"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="milliseconds">續(xù)期的時間</param>
        /// <returns></returns>
        public async static Task Delay(IDatabase redisDb, string key, string value, int milliseconds)
        {
            if (!AutoDelayHandler.Instance.ContainsKey(key))
                return;

            var script = @"local val = redis.call('GET', @key)
                                    if val==@value then
                                        redis.call('PEXPIRE', @key, @milliseconds)
                                        return 1
                                    end
                                    return 0";
            object parameters = new { key, value, milliseconds };
            var prepared = LuaScript.Prepare(script);
            var result = await redisDb.ScriptEvaluateAsync(prepared, parameters, CommandFlags.None);
            if ((int)result == 0)
            {
                AutoDelayHandler.Instance.CloseTask(key);
            }
            return;
        }

保存自動續(xù)期任務(wù)的處理器

 public class AutoDelayHandler
 {
     private static readonly Lazy<AutoDelayHandler> lazy = new Lazy<AutoDelayHandler>(() => new AutoDelayHandler());
     private static ConcurrentDictionary<string, (Task, CancellationTokenSource)> _tasks = new ConcurrentDictionary<string, (Task, CancellationTokenSource)>();

     public static AutoDelayHandler Instance => lazy.Value;

     /// <summary>
     /// 任務(wù)令牌添加到集合中
     /// </summary>
     /// <param name="key"></param>
     /// <param name="task"></param>
     /// <returns></returns>
     public bool TryAdd(string key, Task task, CancellationTokenSource token)
     {
         if (_tasks.TryAdd(key, (task, token)))
         {
             task.Start();

             return true;
         }
         else
         {
             return false;
         }
     }


     public void CloseTask(string key)
     {
         if (_tasks.ContainsKey(key))
         {
             if (_tasks.TryRemove(key, out (Task, CancellationTokenSource) item))
             {
                 item.Item2?.Cancel();
                 item.Item1?.Dispose();
             }
         }
     }

     public bool ContainsKey(string key)
     {
         return _tasks.ContainsKey(key);
     }
 }

在申請帶有自動續(xù)期的分布式鎖的完整代碼

/// <summary>
/// 獲取鎖
/// </summary>
/// <param name="cacheKey"></param>
/// <param name="timeoutSeconds">超時時間</param>
/// <param name="autoDelay">是否自動續(xù)期</param>
/// <returns></returns>
public static async Task<(bool Success, string LockValue)> LockAsync(string cacheKey, int timeoutSeconds = 5, bool autoDelay = false)
{
    var lockKey = GetLockKey(cacheKey);
    var lockValue = Guid.NewGuid().ToString();
    var timeoutMilliseconds = timeoutSeconds * 1000;
    var expiration = TimeSpan.FromMilliseconds(timeoutMilliseconds);
    bool flag = await _redisDb.StringSetAsync(lockKey, lockValue, expiration, When.NotExists);
    if (flag && autoDelay)
    {
        //需要自動續(xù)期，創(chuàng)建后臺任務(wù)
        CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
        var autoDelaytask = new Task(async () =>
        {
            while (!cancellationTokenSource.IsCancellationRequested)
            {
                await Task.Delay(timeoutMilliseconds / 2);
                await Delay(lockKey, lockValue, timeoutMilliseconds);
            }
        }, cancellationTokenSource.Token);
        var result = AutoDelayHandler.Instance.TryAdd(lockKey, autoDelaytask, cancellationTokenSource);

        if (!result) 
        {
            autoDelaytask.Dispose();
            await UnLockAsync(cacheKey, lockValue);
            return (false, string.Empty);
        }
    }
    return (flag, flag ? lockValue : string.Empty);
}

Redis的過期時間精度約為1秒，且過期檢查是周期性執(zhí)行的（默認每秒10次）。選擇TTL/2的間隔能：

確保在Redis下一次過期檢查前完成續(xù)期。

兼容Redis的主從同步延遲（通常<1秒）

StackExchange.Redis分布式鎖

獲取鎖

string lockKey = "order:88888944010:lock";
string lockValue = Guid.NewGuid().ToString(); // 唯一標(biāo)識鎖持有者
TimeSpan expiry = TimeSpan.FromSeconds(10);   // 鎖自動過期時間
// 嘗試獲取鎖（原子操作）
bool lockAcquired = db.LockTake(lockKey, lockValue, expiry);

釋放鎖

 bool released = await ReleaseLockAsync(db, lockKey, lockValue);

自動續(xù)期

同樣需要自己實現(xiàn)

到此這篇關(guān)于C#使用StackExchange.Redis實現(xiàn)分布式鎖的兩種方式介紹的文章就介紹到這了,更多相關(guān)C# StackExchange.Redis實現(xiàn)分布式鎖內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: