分布式锁之redis实现

前言

传统的锁(比如编程语言里的lock)，都是对多线程进行控制，但是对多进程、或者多客户端就无能为力了，为此，就诞生了分布式锁。

通常，redis会被用作缓存功能，但是，它也可以有其他的一些用途。本文，就是利用redis实现分布式锁功能。当然，实现分布式锁还有很多种其他方式，比如：

• 基于数据库乐观锁
• 基于ZooKeeper的分布式锁

不管哪种方式，他的基本原理是不变的：用一个状态值表示锁，对锁的占用和释放通过状态值来标识。

基本原理

redis为单进程单线程模式，采用队列模式将并发访问变成串行访问，且多客户端对redis的连接并不存在竞争关系。

关键命令

> SETNX key value
# SETNX: SET if Not eXists
# 将key的值设置为value
# 当key存在时，不做任何操作，返回   0
# 当key不存在时，进行设置操作，返回 1

> GET key
# 返回key的值

> GETSET key value
# 返回key的旧值，同时将key的值设置成value

实现的基本思想

key为任意值，value代表过期时间(unix time = now + expire)

实现Lock函数，此函数进行一次加锁尝试。

首先调用SETNX设置，如果成功，则成功获得锁。否则，用GET获取key值，和当前时间比较，如果对比发现过期，放弃加锁。否则进行下一步。用GETSET获取key值，如果发现未过期，则加锁成功。 如果过期，则表示有其他客户端已经先于本客户端设置，放弃加锁。

Talk is cheap, show me the code.

下面，就用一个redis单实例实现分布式锁。如果是多客户端使用，确保客户端时间一致。

/*
 expire: N秒后锁失效，允许其他客户端竞争
*/
func Lock(conn redis.Conn, key string, expire int) bool {
    var now int64 = time.Now().Unix()

    r1, err := conn.Do("SETNX", key, now+int64(expire))
    if err != nil {
        return false
    }

    v1, err := redis.Int(r1, err)
    if err != nil {
        return false
    }

    if v1 == 1 {
        return true
    }

    /*此时key存在，查看对应的值*/
    r, err := conn.Do("GET", key)
    if err != nil {
        return false
    }

    v2, err := redis.Int64(r, err)
    if err != nil {
        return false
    }

    if now < v2 {
        /*值未过期，表示其他客户端占用资源，放弃锁*/
        return false
    } else {
        /*获取旧值，设置新值*/
        r, err := conn.Do("GETSET", key, now+int64(expire))
        if err != nil {
            return false
        }

        v3, err := redis.Int64(r, err)
        if err != nil {
            return false
        }

        if now >= v3 {
            return true
        }
        /*
          else情况：表示其他redis客户端抢先一步设置成功，此时放弃锁
          return false
        */
    }

    return false
}

/*
 释放锁
*/
func Unlock(conn redis.Conn, key string) bool {
    var _, err = conn.Do("DEL", key)
    if err != nil {
        return false
    }

    return true
}

/*
 尝试加锁
*/
func TryLock(conn redis.Conn, key string, expire int, timeout int) bool {
    var b = Lock(conn, key, expire)
    if b {
        return b
    }

    if timeout == 0 {
        return false
    }
    var ticker = time.NewTicker(time.Duration(timeout) * time.Second)
    defer ticker.Stop()
    for {
        select {
        case <-time.After(100 * time.Millisecond):
            if Lock(conn, key, expire) {
                /*成功lock后返回，否则一直持续到超时*/
                return true
            }
        }

        select {
        case <-ticker.C:
            return false
        default:
            //DO NOTHING
        }
    }
}