前言

在项目中咱们常常有需求运用分布式锁的场景，而Redis是完结分布式锁最常见的一种方式，这篇文章主要是运用Go+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 <-ctx.Done():
			// 超时
			return ErrTimeout
		case <-ticker.C:
			// 从头测验加锁
			err := l.TryLock(ctx)
			if err == nil {
				return nil
			}
			if !errors.Is(err, ErrLockFailed) {
				return err
			}
		}
	}
}

完结看门狗机制

咱们前面的比如中说到的互斥锁有一个小问题，便是如果持有锁客户端A被堵塞，那么A的锁或许会超时被主动开释，导致客户端B提前获取到锁。

为了削减这种状况的产生，咱们能够在A持有锁期间，不断地延伸锁的过期时刻，削减客户端B提前获取到锁的状况，这便是看门狗机制。

当然，这没办法完全避免上述状况的产生，由于如果客户端A获取锁之后，刚好与Redis的衔接封闭了，这时分也就没办法延伸超时时刻了。

看门狗完结

加锁成功时发动一个线程，不断地延伸锁的过期时刻；在Unlock时封闭看门狗线程。

看门狗流程如下：

• 加锁成功，发动看门狗
• 看门狗线程不断延伸锁的过程时刻
• 解锁，封闭看门狗

func (l *Lock) startWatchDog() {
	ticker := time.NewTicker(l.ttl / 3)
	defer ticker.Stop()
	for {
		select {
		case <-ticker.C:
			// 延伸锁的过期时刻
			ctx, cancel := context.WithTimeout(context.Background(), l.ttl/3*2)
			ok, err := l.client.Expire(ctx, l.resource, l.ttl).Result()
			cancel()
			// 反常或锁现已不存在则不再续期
			if err != nil || !ok {
				return
			}
		case <-l.watchDog:
			// 现已解锁
			return
		}
	}
}

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 <- client
		}(client)
	}
	// 等候一切获取锁操作完结
	wg.Wait()
	close(successClients)
	// 如果成功加锁得客户端少于客户端数量的一半+1，表明加锁失利
	if len(successClients) < len(l.clients)/2+1 {
		// 就算加锁失利，也要把现已取得的锁给开释掉
		for client := range successClients {
			go func(client *redis.Client) {
				ctx, cancel := context.WithTimeout(context.Background(), ttl)
				l.script.Run(ctx, client, []string{l.resource}, randomValue)
				cancel()
			}(client)
		}
		return ErrLockFailed
	}
	// 加锁成功，发动看门狗
	l.randomValue = randomValue
	l.successClients = nil
	for successClient := range successClients {
		l.successClients = append(l.successClients, successClient)
	}
	return nil
}

看门狗完结

咱们需求延伸一切成功获取到的锁的过期时刻。

func (l *RedLock) startWatchDog() {
	l.watchDog = make(chan struct{})
	ticker := time.NewTicker(resetTTLInterval)
	defer ticker.Stop()
	for {
		select {
		case <-ticker.C:
			// 延伸锁的过期时刻
			for _, client := range l.successClients {
				go func(client *redis.Client) {
					ctx, cancel := context.WithTimeout(context.Background(), ttl-resetTTLInterval)
					client.Expire(ctx, l.resource, ttl)
					cancel()
				}(client)
			}
		case <-l.watchDog:
			// 现已解锁
			return
		}
	}
}

解锁完结

咱们需求解锁一切成功获取到的锁。

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
}

参阅

Redis官方文档