基于redis的分布式锁

1. redis分布式锁原理

redis实现分布式锁其实就是对key进行操作

• 加锁：给对应的lockkey赋值，就进行了加锁操作，其他进程发现该lockkey已经值了有值了，就说明锁已经被别人获取
• 解锁：获取到锁的进程删除这个lockkey
• 锁超时：避免客户端宕机导致无法正常释放锁

 

1.1 加锁

加锁实际上就是在redis中，给lockkey设置一个值，为了避免死锁，给定一个过期时间：

SET lock_key uuid NX PX 5000

上面的操作就是给lock_key设置了一个uuid，并且过期时间为5000ms，如果执行成功就说明获取到了锁

 

1.2 解锁

解锁的过程就是将lock_key删除。但也不能乱删，也就是不能删掉其他客户端获取到的锁。这时候uuid的作用就体现出来

为了保证解锁操作的原子性，可以用LUA脚本完成这一操作。先判断当前锁的字符串是否与传入的值相等，是的话就删除Key，解锁成功

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

 

2. go实现redis分布式锁

首先需要引入第三方依赖：

go get github.com/gomodule/redigo/redis
go get github.com/satori/go.uuid

 

获取到redis连接池完成初始化

var redisPool *redis.Pool

func init() {
	redisPool = getRedisPool()
}

// getRedisPool 获取redis连接池
func getRedisPool() *redis.Pool {
	return &redis.Pool{
		MaxIdle:     1,
		MaxActive:   10,
		IdleTimeout: 180 * time.Second,
		Dial: func() (redis.Conn, error) {
			c, err := redis.Dial("tcp", "xx.xx.xx.xx:6379")
			if err != nil {
				return nil, err
			}

			// 选择db
			c.Do("SELECT", 0)
			return c, nil
		},
	}
}

 

定义我们分布式锁的结构体

type Locker struct {
	Key   string
	Uuid  string
	Error error
}

 

尝试获取到分布式锁，带有超时机制

// TryLock: 尝试锁，带尝试超时机制
func TryLock(key string, timeout time.Duration) (locker *Locker) {

	// 获取uuid
	response, err := uuid.NewV4()
	if err != nil {
		fmt.Println("get uuid failed")
		return
	}
	uid := response.String()

	locker = &Locker{
		Key:  key,
		Uuid: uid,
	}

	// 开始尝试获取锁
	start := time.Now()
	for time.Now().Sub(start) < timeout {
		redisConn := redisPool.Get()
		reply, _ := redis.String(redisConn.Do("SET", locker.Key, locker.Uuid, "EX", 60, "NX"))
		redisConn.Close()

		if reply == "OK" {
			return
		}
		time.Sleep(time.Duration(200) * time.Millisecond)
	}

	locker.Error = errors.New("try to lock timeout")
	return
}

 

业务代码结束之后可以释放锁

func (locker *Locker) Unlock() {
	// 只有获取到锁的时候才可以释放锁
	if lock.Error == nil {
		redisConn := redisPool.Get()
		defer redisConn.Close()
		reply, err := redisConn.Do("GET", locker.Key)
		if err != nil {
			fmt.Println("redis connect failed")
			return
		}
		redisUUID := reply.([]byte)

		// 确定这是自己的锁
		if string(redisUUID) == locker.Uuid {
			reply, _ := redisConn.Do("DEL", locker.Key)
			if reply != "OK" {
				fmt.Println("delete key failed")
				return
			}
		}
	}
}