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}";
        }

            await LockAsync("order-88888944010",30); //獲取鎖，并且設(shè)置超時(shí)時(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;
        }

        /// <summary>
        /// 自動(dòng)續(xù)期
        /// </summary>
        /// <param name="redisDb"></param>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="milliseconds">續(xù)期的時(shí)間</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;
        }

 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);
     }
 }

/// <summary>
/// 獲取鎖
/// </summary>
/// <param name="cacheKey"></param>
/// <param name="timeoutSeconds">超時(shí)時(shí)間</param>
/// <param name="autoDelay">是否自動(dòng)續(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)
    {
        //需要自動(dòng)續(xù)期，創(chuàng)建后臺(tái)任務(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);
}

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

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