【愚公系列】2022年11月 .NET CORE工具案例-StackExchange.Redis代码变量方式实现商品秒杀

---

前言

下面是Redis分布式锁常用的概念说明：设置、获取、过期时间、删除。

1、 Setnx

• 命令：SETNX key value
• 说明：将 key 的值设为 value ，当且仅当 key 不存在。若给定的 key 已经存在，则 SETNX 不做任何动作。SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。 时间复杂度：O(1)
• 返回值：设置成功，返回1 ； 设置失败，返回 0

2、Getset

• 命令：GETSET key value
• 说明：将给定 key 的值设为 value ，并返回 key 的旧值(old value)。当 key 存在但不是字符串类型时，返回一个错误。 时间复杂度：O(1)
• 返回值：返回给定 key 的旧值; 当 key 没有旧值时，也即是， key 不存在时，返回 nil 。

3、Expire

• 命令：EXPIRE key seconds
• 说明：为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。 时间复杂度：O(1)
• 返回值：设置成功返回 1 ；当 key 不存在或者不能为 key 设置生存时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的生存时间)，返回 0 。

4、Del

• 命令：DEL key [key …]
• 说明：删除给定的一个或多个 key 。不存在的 key 会被忽略。 时间复杂度：O(N); N 为被删除的 key 的数量。删除单个字符串类型的 key ，时间复杂度为O(1)。 删除单个列表、集合、有序集合或哈希表类型的 key ，时间复杂度为O(M)， M为以上数据结构内的元素数量。

锁的分类说明：

一、StackExchange.Redis执行Lua脚本实现商品秒杀

以下以.NET 7控制台为实例测试

1.StackExchange.Redis封装

using StackExchange.Redis;

namespace Redis
{
    public class RedisHelper
    {
        #region Fileds
        private static string? _redisConnection= "127.0.0.1:6379,defaultDatabase=1";
        private static int _db = 0;
        private static ConnectionMultiplexer? connection;
        #endregion

        #region Constructors
        public RedisHelper()
        {

        }

        public static ConnectionMultiplexer CacheConnection
        {
            get
            {
                try
                {
                    if (connection == null || !connection.IsConnected)
                    {
                        connection = new Lazy<ConnectionMultiplexer>(() => ConnectionMultiplexer.Connect(_redisConnection!)).Value;
                    }
                }
                catch (Exception ex)
                {
                    return null;
                }
                return connection;
            }
        }
        #endregion


        #region Methons

        /// 

        /// 缓存当前数据库
        /// 
        public static IDatabase CacheRedis => CacheConnection.GetDatabase(_db);

        /// 

        /// 新增单条值
        /// 
        /// 
        /// 
        public static bool StringSet(string key, string values)
        {
            if (string.IsNullOrEmpty(key) && string.IsNullOrEmpty(values))
                throw new AggregateException("values or is null");
            return CacheRedis.StringSet(key, values);
        }

        /// 

        /// 查询单个key值
        /// 
        /// 
        /// 
        public static RedisValue GetStringKey(string key)
        {
            return CacheRedis.StringGet(key);
        }

        /// 

        /// 判断key是否存储
        /// 
        /// redis key
        /// 
        public bool KeyExists(string key)
        {
            return CacheRedis.KeyExists(key);
        }

        /// 

        /// 删除单个key
        /// 
        /// redis key
        /// 是否删除成功
        public bool KeyDelete(string key)
        {
            return CacheRedis.KeyDelete(key);
        }

        /// 

        /// redis加锁
        /// 
        /// 需要加锁的锁名
        /// 需要加锁的值
        /// 该锁自动到期时间,如果没其他要求可设置为最大时常,该方式一定要手动解锁
        /// 
        #region 分布式锁
        public static bool LockByRedis(string key, string values)
        {
            try
            {
                //expireTimeSeconds = expireTimeSeconds > 20 ? 10 : expireTimeSeconds;
                //var data = TimeSpan.FromSeconds(expireTimeSeconds);
                //var token = Environment.MachineName;              
                //bool lockflag = CacheRedis.LockTake(key, Thread.CurrentThread.ManagedThreadId, TimeSpan.FromSeconds(expireTimeSeconds));

                bool lockflag = CacheRedis.LockTake(key, values, TimeSpan.MaxValue);
                if (!lockflag)
                {
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                throw new Exception($"Redis加锁异常:原因{ex.Message}");
            }
        }

        /// 

        /// 解锁
        /// 
        /// 需要解锁的锁名
        /// 需要解锁的值
        /// 
        /// 
        public static bool UnLockByRedis(string key, string valuse)
        {
            try
            {
                // Thread.CurrentThread.ManagedThreadId
                //Environment.MachineName
                return CacheRedis.LockRelease(key, valuse);
            }
            catch (Exception ex)
            {
                throw new Exception($"Redis加锁异常:原因{ex.Message}");
            }
        }

        #endregion
        #endregion
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

2.秒杀代码

using Redis;

int count=11;

Console.WriteLine($"进入秒杀时刻，进入时间{DateTime.Now}");

Parallel.For(0, 1000, i =>
{
    //锁键-值
    var lockKey = "lockKey";
    var lockValue = Guid.NewGuid().ToString("N");
    //加锁
    bool result = RedisHelper.LockByRedis(lockKey, lockValue);

    if (!result)
    {
        Console.WriteLine("没有抢到锁，这次请求停止");
        return;
    }
   

    string data = RedisHelper.GetStringKey("Sum").ToString();
    int sum = int.Parse(string.IsNullOrEmpty(data) ? "0" : data);


    if (sum <= 0)
    {
        RedisHelper.StringSet("Sum", count.ToString());
    }
    else
    {
        if (sum <=count)
        {
            count--;
            Console.WriteLine("商品还剩：" + sum.ToString());
            
            RedisHelper.StringSet("Sum", count.ToString());
        }
    }
    
    //释放锁
    var unlock = RedisHelper.UnLockByRedis(lockKey, lockValue);
});

Console.WriteLine($"结束秒杀时刻，结束时间{DateTime.Now}");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

3.效果