Go语言实现Redis分布式锁

基于go-redis的设计与实现

本文将基于go语言，使用了一个常用的go Redis客户端 go-redis库 , 一步一步探索与实现一个简单的Redis分布式锁。

项目地址：https://github.com/liwook/Redislock

连接Redis

​
func NewClient() *redis.Client {
	return redis.NewClient(&redis.Options{
		Addr:     "127.0.0.1:6379",    //自己的redis实例的ip和port
		Password: "",    //密码，有设置的话，就需要填写
	})
}

func main() {
	client := NewClient()
	defer client.Close()

	val, _ := client.Ping().Result()    //测试ping
	fmt.Println(val)
}

1.基于 SETNX 的锁初步实现

SETNX 命令用于在Redis中设置某个不存在的键的值。如果该键不存在，则设置成功，如果该键存在，则设置失败，不作任何动作。基于此可以实现一种简单的抢占机制。

新建lock.go文件。创建lock结构体，添加加锁和解锁方法。

结构体RedisLock有成员key，过期时间expire，连接的redis客户端redisCli。

var (
	defaultExpireTime = 5 * time.Second
)

type RedisLock struct {
	key      string
	expire   time.Duration
	redisCli *redis.Client
}

func NewRedisLock(cli *redis.Client, key string) *RedisLock {
	return &RedisLock{
		key:      key,
		expire:   defaultExpireTime,
		redisCli: cli,
	}
}

加锁

func (lock *RedisLock) Lock() (bool, error) {
	return lock.redisCli.SetNX(lock.key, "111111", lock.expire).Result()
}

上面的加锁是一种简单的方法，非阻塞的，一有结果就直接返回，也不再二次尝试的。lock.redisCli.SetNX(lock.key, "111111", lock.expire) 这行代码本质上执行了如下Redis操作命令：

set key 111111 ex 5 nx

该命令为 my_lock 键以 NX 方式设置了值。

如果持有锁的进程万一挂了，那么该键将永远存在与Redis中，其他竞争者无法进行 SETNX 操作，形成死锁。为了防范这种情况发生，这里设置了过期时间为5s，这样即便持锁者挂了，锁在一定时间后依然后自动释放。这里整个 set 操作是原子性的，并对该操作的返回结果作了判断，如果成功设置，说明抢占锁成功，则函数返回，进入临界区可以继续执行下面的代码。

解锁

func (lock *RedisLock) Unlock() error {
	res, err := lock.redisCli.Del(lock.key).Result()
	if err != nil {
		return err
	}
	if res != 1 {
		return errors.New("can not unlock because del result not is one")
	}
	return nil
}

上述代码中，lock.redisCli.Del(lock.key)对Redis中的lock 键进行了删除操作，当删除后，其他竞争者才有机会对该键进行 SETNX操作。

测试使用

func main() {
	client := NewClient()
	defer client.Close()

	val, _ := client.Ping().Result()
	fmt.Println(val)

	key := "mylock"
	lock1 := redislock.NewRedisLock(client, key)
	lock2 := redislock.NewRedisLock(client, key)

	var wg sync.WaitGroup
	wg.Add(1)

	go func() {
		//尝试获取锁
		if success, err := lock1.Lock(); success && err == nil {
			fmt.Println("go lock get..")
			time.Sleep(4 * time.Second)
			lock1.Unlock()
		}
		wg.Done()
	}()

	//尝试获取锁
	if success, err := lock2.Lock(); success && err == nil {
		fmt.Println(" main lock get...")
		time.Sleep(7 * time.Second)
		lock2.Unlock()
	}
	wg.Wait()
}

2.锁的防误删实现

上面的就使用Redis实现了一个简单的分布式锁。但会存在个问题，想象一个场景：这个键过期了，但是其持有者线程A仍未完成任务。但这时该键就已经没有，线程B就去获取锁，获取成功了。这时候线程A完成了任务，就去删除键。而这时键是被线程B持有的，而线程A却可以去删除，这就会出了问题。

所以，这里要解决的是只有自己才能删除自己创建的锁。为了解决这种问题，持有者可以给锁添加一个唯一标识，使之只能删除自己的锁。因此需要完善一下加解锁操作：

在结构体RedisLock中添加字段Id,这是唯一标识符，用uuid表示。

在创建锁时候，需要创建出uuid，并赋值给字段Id。

type RedisLock struct {
	key      string
	expire   time.Duration
	Id       string //锁的标识，新添加的，也即是键的value
	redisCli *redis.Client
}

func NewRedisLock(cli *redis.Client, key string) *RedisLock {
	id := strings.Join(strings.Split(uuid.New().String(), "-"), "")
	return &RedisLock{
		key:      key,
		expire:   defaultExpireTime,
		Id:       id,
		redisCli: cli,
	}
}

 那么在加锁的时候，把lock.Id给value赋值。

func (lock *RedisLock) Lock() (bool, error) {
	return lock.redisCli.SetNX(lock.key, lock.Id, lock.expire).Result()
}

//对比之前的
//func (lock *RedisLock) Lock() (bool, error) {
//	return lock.redisCli.SetNX(lock.key, "111111", lock.expire).Result()
//}

解锁的时候，需要先判断锁的唯一标识值是否是与当前拥有者相匹配，若匹配再进行删除。

// 锁的误删除实现
func (lock *RedisLock) Unlock() error {
	//获取锁并进行判断该锁是否是自己的
	val, err := lock.redisCli.Get(lock.key).Result()
	if err != nil {
		fmt.Println("lock not exit")
		return err
	}
	if val == "" || val != lock.Id {
		return errors.New("lock not belong to myself")
	}

	//进行删除锁
	res, err := lock.redisCli.Del(lock.key).Result()
	if err != nil {
		return err
	}
	if res != 1 {
		return errors.New("can not unlock because del result not is one")
	}
	return nil
}

3.解锁的原子化实现

上面的解锁操作中，仍然是存在一个问题的：在确认当前锁是自己的锁后，和删除锁之前，这个时间段，中途可能会进行阻塞，这个过程中，锁恰巧过期释放，且被其他竞争者抢占。那就有可能会删除了其他竞争者的锁。这是不妥的。

我们要把这两个操作变成原子操作，将整个解锁过程原子化，使得在解锁期间，其他竞争者的任何操作不能被Redis执行。

Redis中可以使用Lua脚本把一系列操作变成原子操作。

func (lock *RedisLock) Unlock() error {
	script := redis.NewScript(LauCheckAndDelete)
	res, err := script.Run(lock.redisCli, []string{lock.key}, lock.Id).Int64()
	if err != nil {
		return err
	}
	if res != 1 {
		return errors.New("can not unlock because del result not is one")
	}
	return nil
}


//lua.go
const (
	LauCheckAndDelete = `
		if(redis.call('get',KEYS[1])==ARGV[1]) then
		return redis.call('del',KEYS[1])
		else
		return 0
		end
	`
)

确认锁与删除锁的整体操作进行了原子化，便可以防止上述存在的误删问题。

4.小结

基于Redis的分布式锁的实现思路：

• 利用set nx ex获取锁，并设置过期时间，保存锁的唯一标识
• 释放锁时先判断唯一标识是否与自己一致，一致则删除锁
• 删除锁时候用lua脚本把判断锁唯一标识和删除锁进行原子化

其特性：

• 利用set nx满足互斥性
• 利用set ex来保证故障时锁依然能释放，避免死锁
• 利用Redis集群可以保证高可用和高并发特性