登录
首页 >  Golang >  Go教程

Go与Redis实现分布式互斥锁和红锁

来源:脚本之家

时间:2022-12-22 20:15:59 117浏览 收藏

在Golang实战开发的过程中,我们经常会遇到一些这样那样的问题,然后要卡好半天,等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《Go与Redis实现分布式互斥锁和红锁》,聊聊分布式、互斥锁、Redis、红锁,希望可以帮助到正在努力赚钱的你。

下面的代码使用go-redis客户端和gofakeit库。

代码地址

互斥锁

Redis里有一个设置如果不存在的命令,我们可以通过这个命令来实现互斥锁功能,在Redis官方文档里面推荐的标准实现方式是SET resource_name my_random_value NX PX 30000这串命令,其中:

  • resource_name表示要锁定的资源
  • NX表示如果不存在则设置
  • PX 30000表示过期时间为30000毫秒,也就是30秒
  • my_random_value这个值在所有的客户端必须是唯一的,所有同一key的锁竞争者这个值都不能一样。

值必须是随机数主要是为了更安全的释放锁,释放锁的时候使用脚本告诉Redis:只有key存在并且存储的值和我指定的值一样才能告诉我删除成功,避免错误释放别的竞争者的锁。

由于涉及到两个操作,因此我们需要通过Lua脚本保证操作的原子性:

if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end

举个不用Lua脚本的例子:客户端A取得资源锁,但是紧接着被一个其他操作阻塞了,当客户端A运行完毕其他操作后要释放锁时,原来的锁早已超时并且被Redis自动释放,并且在这期间资源锁又被客户端B再次获取到。

因为判断和删除是两个操作,所以有可能A刚判断完锁就过期自动释放了,然后B就获取到了锁,然后A又调用了Del,导致把B的锁给释放了。

TryLock和Unlock实现

TryLock其实就是使用SET resource_name my_random_value NX PX 30000加锁,这里使用UUID作为随机值,并且在加锁成功时把随机值返回,这个随机值会在Unlock时使用;

Unlock解锁逻辑就是执行前面说到的lua脚本

func (l *Lock) TryLock(ctx context.Context) error {
   success, err := l.client.SetNX(ctx, l.resource, l.randomValue, ttl).Result()
   if err != nil {
      return err
   }
   // 加锁失败
   if !success {
      return ErrLockFailed
   }
   // 加锁成功
   l.randomValue = randomValue
   return nil
}

func (l *Lock) Unlock(ctx context.Context) error {
   return l.script.Run(ctx, l.client, []string{l.resource}, l.randomValue).Err()
}

Lock实现

Lock是阻塞的获取锁,因此在加锁失败的时候,需要重试。当然也可能出现其他异常情况(比如网络问题,请求超时等),这些情况则直接返回error

步骤如下:

  • 尝试加锁,加锁成功直接返回
  • 加锁失败则不断循环尝试加锁直到成功或出现异常情况
func (l *Lock) Lock(ctx context.Context) error {
	// 尝试加锁
	err := l.TryLock(ctx)
	if err == nil {
		return nil
	}
	if !errors.Is(err, ErrLockFailed) {
		return err
	}
	// 加锁失败,不断尝试
	ticker := time.NewTicker(l.tryLockInterval)
	defer ticker.Stop()
	for {
		select {
		case 

实现看门狗机制

我们前面的例子中提到的互斥锁有一个小问题,就是如果持有锁客户端A被阻塞,那么A的锁可能会超时被自动释放,导致客户端B提前获取到锁。

为了减少这种情况的发生,我们可以在A持有锁期间,不断地延长锁的过期时间,减少客户端B提前获取到锁的情况,这就是看门狗机制。

当然,这没办法完全避免上述情况的发生,因为如果客户端A获取锁之后,刚好与Redis的连接关闭了,这时候也就没办法延长超时时间了。

看门狗实现

加锁成功时启动一个线程,不断地延长锁地过期时间;在Unlock时关闭看门狗线程。

看门狗流程如下:

  • 加锁成功,启动看门狗
  • 看门狗线程不断延长锁的过程时间
  • 解锁,关闭看门狗
func (l *Lock) startWatchDog() {
	ticker := time.NewTicker(l.ttl / 3)
	defer ticker.Stop()
	for {
		select {
		case 

TryLock:启动看门狗

func (l *Lock) TryLock(ctx context.Context) error {
	success, err := l.client.SetNX(ctx, l.resource, l.randomValue, l.ttl).Result()
	if err != nil {
		return err
	}
	// 加锁失败
	if !success {
		return ErrLockFailed
	}
	// 加锁成功,启动看门狗
	go l.startWatchDog()
	return nil
}

Unlock:关闭看门狗

func (l *Lock) Unlock(ctx context.Context) error {
	err := l.script.Run(ctx, l.client, []string{l.resource}, l.randomValue).Err()
	// 关闭看门狗
	close(l.watchDog)
	return err
}

红锁

由于上面的实现是基于单Redis实例,如果这个唯一的实例挂了,那么所有请求都会因为拿不到锁而失败,为了提高容错性,我们可以使用多个分布在不同机器上的Redis实例,并且只要拿到其中大多数节点的锁就能加锁成功,这就是红锁算法。它其实也是基于上面的单实例算法的,只是我们需要同时对多个Redis实例获取锁。

加锁实现

在加锁逻辑里,我们主要是对每个Redis实例执行SET resource_name my_random_value NX PX 30000获取锁,然后把成功获取锁的客户端放到一个channel里(这里因为是多线程并发获取锁,使用slice可能有并发问题),同时使用sync.WaitGroup等待所有获取锁操作结束。

然后判断成功获取到的锁的数量是否大于一半,如果没有得到一半以上的锁,说明加锁失败,释放已经获得的锁。

如果加锁成功,则启动看门狗延长锁的过期时间。

func (l *RedLock) TryLock(ctx context.Context) error {
	randomValue := gofakeit.UUID()
	var wg sync.WaitGroup
	wg.Add(len(l.clients))
	// 成功获得锁的Redis实例的客户端
	successClients := make(chan *redis.Client, len(l.clients))
	for _, client := range l.clients {
		go func(client *redis.Client) {
			defer wg.Done()
			success, err := client.SetNX(ctx, l.resource, randomValue, ttl).Result()
			if err != nil {
				return
			}
			// 加锁失败
			if !success {
				return
			}
			// 加锁成功,启动看门狗
			go l.startWatchDog()
			successClients 

看门狗实现

我们需要延长所有成功获取到的锁的过期时间。

func (l *RedLock) startWatchDog() {
	l.watchDog = make(chan struct{})
	ticker := time.NewTicker(resetTTLInterval)
	defer ticker.Stop()
	for {
		select {
		case 

解锁实现

我们需要解锁所有成功获取到的锁。

func (l *RedLock) Unlock(ctx context.Context) error {
   for _, client := range l.successClients {
      go func(client *redis.Client) {
         l.script.Run(ctx, client, []string{l.resource}, l.randomValue)
      }(client)
   }
   // 关闭看门狗
   close(l.watchDog)
   return nil
}

好了,本文到此结束,带大家了解了《Go与Redis实现分布式互斥锁和红锁》,希望本文对你有所帮助!关注golang学习网公众号,给大家分享更多Golang知识!

声明:本文转载于:脚本之家 如有侵犯,请联系study_golang@163.com删除
相关阅读
更多>
最新阅读
更多>
课程推荐
更多>
评论列表