前言

　　我們之前聊過redis的，對基礎不了解的可以移步查看一下：

幾分鐘搞定redis存盤session共享——設計實作：https://www.cnblogs.com/xiongze520/p/10333233.html

【原創】詳細案例解剖——淺談Redis快取的常用5種方式（String，Hash，List，set，SetSorted ）：https://www.cnblogs.com/xiongze520/p/10267804.html

　　對同一個資源進行操作，單一的快取讀取沒問題了，但是存在并發的時候怎么辦呢，為了避免資料不一致，我們需要在操作共享資源之前進行加鎖操作，

我們在開發很多業務場景會使用到鎖，例如庫存控制，抽獎，秒殺等，一般我們會使用記憶體鎖的方式來保證線性的執行，

但現在大多站點都會使用分布式部署，那多臺服務器間的就必須使用同一個目標來判斷鎖，分布式與單機情況下最大的不同在于其不是多執行緒而是多行程，

　　　　　　　　 圖1：分布式站點使用記憶體鎖

  　　　　　　　　圖2：分布式站點使用分布式鎖

當然我們暫時用不了這么復雜的場景，我們就簡單訪問redis就行，

設計（悲觀鎖/樂觀鎖）

悲觀鎖方式（認為操作的時候，會出現問題，所以都加鎖）

悲觀鎖(Pessimistic Lock), 顧名思義，就是很悲觀，每次去拿資料的時候都認為別人會修改，
所以每次在拿資料的時候都會上鎖，這樣別人想拿這個資料就會block直到它拿到鎖，
傳統的關系型資料庫里邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前先上鎖，

樂觀鎖方式（認為什么時候不會出問題，所以不上鎖，更新的時候去查詢判斷一下，再此期間是否有人修改過這個資料，）

樂觀鎖(Optimistic Lock), 顧名思義，就是很樂觀，每次去拿資料的時候都認為別人不會修改，
所以不會上鎖，但是在更新的時候會判斷一下在此期間別人有沒有去更新這個資料，可以使用版本號等機制，
樂觀鎖適用于多讀的應用型別，這樣可以提高吞吐量，像資料庫如果提供類似于write_condition機制的其實都是提供的樂觀鎖，

　　兩種鎖各有優缺點，不可認為一種好于另一種，像樂觀鎖適用于寫比較少的情況下，即沖突真的很少發生的時候，這樣可以省去了鎖的開銷，
加大了系統的整個吞吐量，但如果經常產生沖突，上層應用會不斷的進行retry，這樣反倒是降低了性能，所以這種情況下用悲觀鎖就比較合適，

Redis三個命令

1、SETNX

SETNX key value：當且僅當key不存在時，set一個key為val的字串，回傳1；若key存在，則什么都不做，回傳0，

2、expire

expire key timeout：為key設定一個超時時間，單位為second，超過這個時間鎖會自動釋放，避免死鎖，

3、delete

delete key：洗掉key

在使用Redis實作分布式鎖的時候，主要就會使用到這三個命令，

命題：某商品進行庫存秒殺，

假設要給某個商品舉行秒殺活動，我們事先把庫存資料100已經存入到了redis中，我們現在需要來進行庫存扣減，

　　　　　　 　　　　　　圖3：加鎖請求示意圖

代碼實作

我們基于 ServiceStack.Redis 操作

我們創建一個控制臺應用(.NET Framework)，命名為 RedisLock ,注意，如果創建的是net core的應用，引入的ServiceStack.Redis就要選擇core的，

然后在NuGet里面安裝ServiceStack.Redis，

Redis連接池

       //Redis連接池（配置連接地址，讀寫連接地址等）
        public static PooledRedisClientManager RedisClientPool = CreateManager();
        private static PooledRedisClientManager CreateManager()
        {
            //寫節點(主節點)
            List<string> writes = new List<string>();
            writes.Add("10.17.3.97:6379");  
            //讀節點
            List<string> reads = new List<string>();
            reads.Add("10.17.3.97:6379");

            //配置連接池和讀寫分類
            return new PooledRedisClientManager(writes, reads, new RedisClientManagerConfig()
            {
                MaxReadPoolSize = 50, //讀節點個數
                MaxWritePoolSize = 50,//寫節點個數
                AutoStart = true,
                DefaultDb = 0
            });
        }

使用Redis的SetNX命令實作加鎖

        /// <summary>
        /// 加鎖（使用Redis的SetNX命令實作加鎖）
        /// </summary>
        /// <param name="key">鎖key</param>
        /// <param name="selfMark">自己標記</param>
        /// <param name="lockExpirySeconds">鎖自動過期時間[默認10]（s）</param>
        /// <param name="waitLockMilliseconds">等待鎖時間（ms）</param>
        /// <returns></returns>
        public static bool Lock(string key, out string selfMark, int lockExpirySeconds = 10, long waitLockMilliseconds = long.MaxValue)
        {
            DateTime begin = DateTime.Now;
            selfMark = Guid.NewGuid().ToString("N");//自己標記,釋放鎖時會用到,自己加的鎖除非過期否則只能自己打開
            using (RedisClient redisClient = (RedisClient)RedisClientPool.GetClient())
            {
                
                string lockKey = "Lock:" + key;
                while (true)
                {
                    string script = string.Format("if redis.call('SETNX', KEYS[1], ARGV[1]) == 1 then redis.call('PEXPIRE',KEYS[1],{0}) return 1 else return 0 end", lockExpirySeconds * 1000);
                    //回圈獲取取鎖
                    if (redisClient.ExecLuaAsInt(script, new[] { lockKey }, new[] { selfMark }) == 1)
                    {
                        return true;
                    }

                    //不等待鎖則回傳
                    if (waitLockMilliseconds == 0)
                    {
                        break;
                    }

                    //超過等待時間，則不再等待
                    if ((DateTime.Now - begin).TotalMilliseconds >= waitLockMilliseconds)
                    {
                        break;
                    }
                    Thread.Sleep(100);
                }

                return false;
            }
        }

因為ServiceStack.Redis提供的SetNX方法，并沒有提供設定過期時間的方法，對于加鎖業務又不能分開執行(如果加鎖成功設定過期時間失敗導致的永久死鎖問題)，所以就使用腳本實作，解決了例外情況死鎖問題.

如果設定為0，為樂觀鎖機制，獲取不到鎖，直接回傳未獲取到鎖.
默認值為long最大值，為悲觀鎖機制，約等于很多很多天，可以理解為一直等待.

釋放鎖

　　　　 /// <summary>
        /// 釋放鎖
        /// </summary>
        /// <param name="key">鎖key</param>
        /// <param name="selfMark">自己標記</param>
        public static void UnLock(string key, string selfMark)
        {
            using (RedisClient redisClient = (RedisClient)RedisClientPool.GetClient())
            {
                string lockKey = "Lock:" + key;
                var script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                redisClient.ExecLuaAsString(script, new[] { lockKey }, new[] { selfMark });
            }
        }

業務呼叫（我們使用多執行緒模擬多用戶秒殺的場景）

//業務：悲觀鎖方式
        public static void PessimisticLock()
        {
            int num = 10;  //總數量
            string lockkey = "xianseng";

            Console.WriteLine("我是【悲觀鎖】");

            //悲觀鎖開啟20個人同時拿寶貝
            for (int i = 0; i < 20; i++)
            {
                Task.Run(() =>
                {
                    string selfmark = ""; 
                    try
                    {
                        if (Lock(lockkey, out selfmark))
                        {
                            if (num > 0)
                            {
                                num--;
                                Console.WriteLine($"我拿到了寶貝：寶貝剩余{num}個\t\t{selfmark}");
                            }
                            else
                            {
                                Console.WriteLine("寶貝已經沒有了");
                            }
                            Thread.Sleep(100);
                        }
                    }
                    finally
                    {
                        UnLock(lockkey, selfmark);
                    }
                });
            }

            Console.ReadLine();
        }

        //業務：樂觀鎖方式
        public static void OptimisticLock()
        {
            int num = 10; //總數量
            string lockkey = "xianseng";

            Console.WriteLine("我是【樂觀鎖】");

            //樂觀鎖開啟10個執行緒，每個執行緒拿5次
            for (int i = 0; i < 10; i++)
            {
                var lineOn = "執行緒" + (i + 1);
                Task.Run(() =>
                {
                    for (int j = 0; j < 5; j++)
                    {
                        string selfmark = "";
                        try
                        {
                            if (Lock(lockkey, out selfmark, 10, 0))
                            {
                                if (num > 0)
                                {
                                    num--;
                                    Console.WriteLine($"{lineOn} 第{(j+1)}次 我拿到了寶貝：寶貝剩余{num}個\t\t{selfmark}");
                                }
                                else
                                {
                                    Console.WriteLine($"{lineOn} 第{(j + 1)}次 寶貝已經沒有了");
                                }

                                Thread.Sleep(1000);
                            }
                            else
                            {
                                Console.WriteLine($"{lineOn} 第{(j+1)}次 沒有拿到，不想等了");
                            }
                        }
                        finally
                        {
                            UnLock(lockkey, selfmark);
                        }
                    }
                });
            }

            Console.ReadLine();
        }

然后在main函式里面呼叫查看展示效果

       static void Main(string[] args)
        {
            ////呼叫：悲觀鎖方式（認為我操作的時候，會出現問題，所以都加鎖）
            PessimisticLock();

            ///呼叫：樂觀鎖方式（認為什么時候不會出問題，所以不上鎖，更新的時候去查詢判斷一下，再此期間是否有人修改過這個資料，）
            //OptimisticLock();
        }

這就簡單實作了Redis分布鎖的功能，快去試試吧，

參考文獻

• Redis如何實作分布式鎖：https://www.cnblogs.com/laohanshuibi/p/15164807.html
• 淺談Redis快取的常用5種方式（String，Hash，List，set，SetSorted ）：https://www.cnblogs.com/xiongze520/p/10267804.html
• 幾分鐘搞定redis存盤session共享——設計實作：https://www.cnblogs.com/xiongze520/p/10333233.html

標籤：ASP.NET

上一篇：【學習筆記】前端常用基礎知識（一）

下一篇：ASP.NET管道處理模型（一）