分布式系统--封装Redis分布式锁解决跨进程并发秒杀引起的超卖问题

            namespace
             MyRedis.SecKill.MultiProcess.SecKill
{
    
            ///
            <summary>
            ///
             商品秒杀服务
    
            ///
            </summary>
            public
            class
             ProductSecKill
    {
        
            ///
            <summary>
            ///
             秒杀方法
        
            ///
            </summary>
            public
            void
             SecKillProduct()
        {
            RedisLock redisLock = new RedisLock();
            redisLock.Lock();
            //lock (this)//只是适合单进程
            //{
                // 1、获取商品库存var productStock = GetPorductStocks();

                // 2、判断商品库存是否为空if (productStock.Conut == 0)
                {
                    // 2.1 秒杀失败消息
                    Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId}：不好意思，秒杀已结束，商品编号:{productStock.Conut}");
                    redisLock.UnLock();
                    return;
                }

                // 3、秒杀成功消息
                Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId}：恭喜你，秒杀成功，商品编号:{productStock.Conut}");

                // 4、扣减商品库存                SubtracPorductStocks(productStock);
            //}           
            redisLock.UnLock();
        }

        ///<summary>/// 获取商品库存
        ///</summary>///<returns></returns>private Product_Stock GetPorductStocks()
        {
            using (ShoppingEntities shoppingEntities = new ShoppingEntities())
            {
                // 1、查询数据库获取库存，获取第一个商品的库存数
                Product_Stock productStock = shoppingEntities.Product_Stock.FirstOrDefault(s => s.Id == 1);

                // 2、返回库存return productStock;
            }

        }

        ///<summary>/// 扣减商品库存
        ///</summary>privatevoid SubtracPorductStocks(Product_Stock stocks)
        {
            using (ShoppingEntities shoppingEntities = new ShoppingEntities())
            {
                // 1、扣减商品库存
                Product_Stock updateStocks = shoppingEntities.Product_Stock.FirstOrDefault(s => s.Id == stocks.Id);
                updateStocks.Conut = stocks.Conut - 1;

                // 2、更新数据库                shoppingEntities.SaveChanges();
            }
        }
    }
}

            namespace
             MyRedis.SecKill.MultiProcess
{
    
            class
             Program
    {
        
            static
            void Main(string[] args)
        {
            // 1、开始秒杀
            ClientRequest.SendRequest(20);
            Console.ReadKey();
        }
    }
}

            namespace
             MyRedis.SecKill.MultiProcess.SecKill
{
    
            class
             ClientRequest
    {
        
            ///
            <summary>
            ///
             客户端请求
        
            ///
            </summary>
            ///
            <param name="threadCount">
            线程数
            </param>
            public
            static
            void SendRequest(int threadCount)
        {
            // 1、商品秒杀服务
            ProductSecKill productSecKill = new ProductSecKill();
            // 2、创建20个请求来秒杀for (int i = 0; i < threadCount; i++)
            {
                Thread thread = new Thread(() =>
                {
                    productSecKill.SecKillProduct();
                });
                thread.Start();
            }
        }
    }
}

            namespace
             MyRedis.SecKill.MultiProcess.Locks
{
    
            ///
            <summary>
            ///
             redis分布式锁
    
            ///
             分布式锁四要素
    
            ///
             1、锁名
    
            ///
             2、加锁操作
    
            ///
             3、解锁操作
    
            ///
             4、锁超时时间
    
            ///
            </summary>
            class
             RedisLock
    {
        
            //
             1、redis连接管理类
            private ConnectionMultiplexer connectionMultiplexer = null;

        // 2、redis数据操作类private IDatabase database = null;
        public RedisLock()
        {
            connectionMultiplexer = ConnectionMultiplexer.Connect("localhost:6379");

            database = connectionMultiplexer.GetDatabase(0);
        }

        ///<summary>/// 1、加锁
        ///</summary>publicvoid Lock()
        {
            // 1、redis加锁api--LockTake
            // key--锁名--redis_lock
            // value--锁对象(谁持有这把锁)--进程Id+线程Id
            // expiry--锁超时时间，为什么？解锁死锁问题！
            // 2、如果加锁失败？循环加锁，对于未知的事情用循环while (true)
            {
                bool flag = database.LockTake("redis_lock", "ProcessNo1" +Thread.CurrentThread.ManagedThreadId, TimeSpan.FromSeconds(10));

                // 3、如果加锁成功，则退出循环if (flag)
                {
                    break;
                }

                // 3.1 加锁失败，线程休眠下，走循环，再尝试加锁
                Thread.Sleep(200);
            }
        }

        ///<summary>/// 2、解锁
        ///</summary>publicvoid UnLock()
        {
            //1、redis解锁api--LockRelease
            // key--锁名--redis_lock
            // value--锁对象(谁持有这把锁)--进程Id+线程Id--使加锁和解锁是同一个对象
            // 2、如果解锁失败？循环解锁，对于未知的事情用循环bool flag = database.LockRelease("redis_lock", "ProcessNo1" +Thread.CurrentThread.ManagedThreadId);
            while (true) 
            {
                // 3、如果解锁成功，则退出循环if (flag)
                {
                    break;
                }

                // 3.1 解锁失败，线程休眠下，走循环，再尝试解锁
                Thread.Sleep(200);
            }
            // 4、关闭资源            connectionMultiplexer.Dispose();
        }
    }
}