Redis分布式锁抽丝剥茧

存储 存储软件 分布式 Redis
最近首度应用"分布式锁",现在想想,分布式锁不是孤立的技能点,这其实就是跨主机的线程同步。

[[405785]]

分布式锁是"线程同步"的延续

最近首度应用"分布式锁",现在想想,分布式锁不是孤立的技能点,这其实就是跨主机的线程同步。

进程内 跨进程 跨主机
Lock/Monitor、SemaphoreSlim Metux、Semaphore 分布式锁
用户态线程安全 内核态线程安全  

单机服务器可以通过共享某堆内存来标记上锁/解锁,线程同步说到底是建立在单机操作系统的用户态/内核态对共享内存的访问控制。

而分布式服务器不是在同一台机器上:跨主机,因此需要将锁标记存储在所有机器进程都能看到的地方。

在开发很多业务场景会使用到锁,例如库存控制,抽奖等。

例如库存只剩1个商品,有三个用户同时打算购买,谁先购买库存立即清零,不能让其他二人也购买成功。

解读分布式锁

我们常说的线程安全、线程同步方案,包括此次的分布式锁都是基于

“多线程/多进程对特定资源同时有更新操作”。

基本考量

1.分布式系统,一个锁在同一时间只能被一个服务器获取 (这是分布式锁的基础)

2.具备锁失效机制,防止死锁 (防止某些意外,锁没有得到释放,别人也无法得到锁)

Redis SET resource-name anystring NX EX max-lock-time

是一种最简单的分布式锁实现方案。

SET 命令支持多个参数:

  • EX seconds-- 设置过期时间(s)
  • NX -- 如果key不存在,则设置 ......

因为SET命令参数可以替代SETNX,SETEX,GETSET,这些命令在未来可能被废弃。

上面的命令返回OK(或经过重试),客户端就获取到这个锁;

使用DEL命令解锁;到达超时时间会自动释放锁。

在解锁时,增加一些设计,让系统更加健壮:

3.不要使用固定的String值作为锁标记值,而是使用一个不易被猜中的随机值, 业内称为token

4.不使用DEL命令释放锁,而是发送script去移除key

第3、4点是为了解决 :“锁提前过期,客户端A还没有执行完,然后客户端B获取了锁,这时客户端A执行完了,会不会在删锁的时候把B的锁给删掉” -- 4是3技术上的推荐实现。

脚本如下:

  1. if redis.call("get",KEYS1] ==ARGV[1]) 
  2. then 
  3.    return  redis.call("DEL",KEYS[1]) 
  4. else 
  5.   return 0 
  6. end 

下面使用StackExchange.Redis 写了基于以上考量的代码示例:

  1. /// <summary> 
  2. /// Acquires the lock. 
  3. /// </summary> 
  4. /// <param name="key"></param> 
  5. /// <param name="token">随机值</param> 
  6. /// <param name="expireSecond"></param> 
  7.  /// <param name="waitLockSeconds">非阻塞锁</param> 
  8. static bool Lock(string key, string token,int expireSecond=10, double waitLockSeconds = 0) 
  9.     var waitIntervalMs = 50; 
  10.     bool isLock; 
  11.              
  12.     DateTime begin = DateTime.Now; 
  13.     do 
  14.     { 
  15.          isLock = Connection.GetDatabase().StringSet(key, token, TimeSpan.FromSeconds(expireSecond), When.NotExists); 
  16.          if (isLock) 
  17.              return true
  18.              //不等待锁则返回 
  19.              if (waitLockSeconds == 0) break; 
  20.              //超过等待时间,则不再等待 
  21.              if ((DateTime.Now - begin).TotalSeconds >= waitLockSeconds) break; 
  22.              Thread.Sleep(waitIntervalMs); 
  23.      } while (!isLock); 
  24.      return false
  25.  } 
  26.         
  27. /// <summary>   
  28. /// Releases the lock.   
  29. /// </summary>   
  30. /// <returns><c>true</c>, if lock was released, <c>false</c> otherwise.</returns>   
  31. /// <param name="key">Key.</param>   
  32. /// <param name="value">value</param>   
  33. static bool UnLock(string key, string value) 
  34.     string lua_script = @"   
  35.     if (redis.call('GET', KEYS[1]) == ARGV[1]) then   
  36.          redis.call('DEL', KEYS[1])   
  37.           return true   
  38.           else   
  39.           return false   
  40.         end   
  41.       "; 
  42.      try 
  43.      { 
  44.           var res = Connection.GetDatabase().ScriptEvaluate(lua_script, 
  45.                                                            new RedisKey[] { key }, 
  46.                                                            new RedisValue[] { value }); 
  47.             return (bool)res; 
  48.       } 
  49.      catch (Exception ex) 
  50.      { 
  51.           Console.WriteLine($"ReleaseLock lock fail...{ex.Message}"); 
  52.           return false
  53.      } 
  54.          
  55.         private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() => 
  56.         { 
  57.             ConfigurationOptions configuration = new ConfigurationOptions 
  58.             { 
  59.                 AbortOnConnectFail = false
  60.                 ConnectTimeout = 5000, 
  61.             }; 
  62.             configuration.EndPoints.Add("10.100.219.9", 6379); 
  63.             return ConnectionMultiplexer.Connect(configuration.ToString()); 
  64.         });  
  65.         public static ConnectionMultiplexer Connection => lazyConnection.Value; 

以上代码新增了第五点考量:

5. 为避免无限制抢锁,增加了非阻塞锁:轮询_s等待锁,未等到则不再抢锁

使用方式:

下面并行开启三个任务,同时减少库存:

  1. static void Main(string[] args) 
  2.      // 尝试并行执行3个任务 
  3.      Parallel.For(0, 3, x => 
  4.      { 
  5.            string token = $"loki:{x}"
  6.            bool isLocked = Lock("loki", token, 5, 10); 
  7.              
  8.            if (isLocked) 
  9.            { 
  10.                Console.WriteLine($"{token} begin reduce stocks (with lock) at {DateTime.Now}."); 
  11.                Thread.Sleep(1000); 
  12.                Console.WriteLine($"{token} release lock {UnLock("loki", token)} at {DateTime.Now}. "); 
  13.            } 
  14.            else 
  15.            { 
  16.              Console.WriteLine($"{token} begin reduce stocks at {DateTime.Now}."); 
  17.            } 
  18.        }); 

可以看到三个并行任务依次获取/释放锁

输出总结

 

本文从基础的线程安全、线程同步,认识到分布式锁是跨主机的资源线程/进程同步方案, 以步步为营的风格 演示了RedisSET命令做分布式锁的设计考量,好记性不如烂笔头。

 

责任编辑:武晓燕 来源: 精益码农
相关推荐

2021-06-11 18:27:10

LinuxLinux内核

2024-04-01 00:07:20

LinuxeBPF源码

2022-07-05 21:31:21

索引SQL分库分表

2022-07-11 11:28:45

数据分析业务消费

2022-01-17 17:55:29

Python变量交换开发

2015-06-09 11:13:18

2020-05-06 08:01:39

黑客恶意攻击网络安全

2019-06-19 15:40:06

分布式锁RedisJava

2023-08-21 19:10:34

Redis分布式

2022-01-06 10:58:07

Redis数据分布式锁

2019-02-26 09:51:52

分布式锁RedisZookeeper

2021-04-19 11:07:13

Windbg程序.NET

2022-09-19 08:17:09

Redis分布式

2020-11-16 12:55:41

Redis分布式锁Zookeeper

2024-10-07 10:07:31

2024-04-01 05:10:00

Redis数据库分布式锁

2019-07-16 09:22:10

RedisZookeeper分布式锁

2022-06-16 08:01:24

redis分布式锁

2023-01-13 07:39:07

2021-07-26 11:09:46

Redis分布式技术
点赞
收藏

51CTO技术栈公众号