redisson分布式锁实现思路

分布式锁要满足四个基本的特点：
1.互斥性
2.加锁和解锁的人必须一致
3.不能发生死锁
4.容错性。

redisson中，通过检查key是否存在来保证唯一性。
同时加锁的时候，加锁的根据redisson客户端uuid+线程id组生成客户端唯一uuid，写入到哈希表中。
每个锁的名称就是key，给每个key设置ttl。一旦过期key就会被删除，保证不会发生死锁。

redisson巧妙的利用redis执行脚本的时候原子执行的特点，将加锁和解锁的过程封装在lua脚本中，实现加锁的原子性。
加锁的脚本：

--[[
/*
*key number:1
*KEYS[1]: 锁名
*ARGV[1]: 锁的存活期
*ARGV[2]: 锁id
*返回值: 0 - ok, >0 - fail
*/
]]--
-- 若锁不存在：则新增锁，并设置锁重入计数为1、设置锁过期时间\
if (redis.call('exists', KEYS[1]) == 0) then
    redis.call('hset', KEYS[1], ARGV[2], 1);
    redis.call('pexpire', KEYS[1], ARGV[1]);
    return nil;
end;
 
-- 若锁存在，且唯一标识也匹配：则表明当前加锁请求为锁重入请求，故锁重入计数+1，并再次设置锁过期时间
if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then
    redis.call('hincrby', KEYS[1], ARGV[2], 1);
    redis.call('pexpire', KEYS[1], ARGV[1]);
    return nil;
end;
 
-- 若锁存在，但唯一标识不匹配：表明锁是被其他线程占用，当前线程无权解他人的锁，直接返回锁剩余过期时间
return redis.call('pttl', KEYS[1]);

加锁lua脚本的过程如下：

1.PNG

解锁lua脚本：

--[[
/*
*key number:2
*KEYS[1]: lock_name
*KEYS[2]: pub_chan_name,would be: hd_dlock_chan:${lock_name}
*ARGV[1]: publish content. 0 - unlock
*ARGV[2]: 锁的存活期
*ARGV[3]: 锁id
*/
]]--

-- 若锁不存在：则直接广播解锁消息，并返回1
if (redis.call('exists', KEYS[1]) == 0) then
    redis.call('publish', KEYS[2], ARGV[1]);
    return 1;
end;
 
-- 若锁存在，但唯一标识不匹配：则表明锁被其他线程占用，当前线程不允许解锁其他线程持有的锁
if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then
    return nil;
end;

-- 若锁存在，且唯一标识匹配：则先将锁重入计数减1
local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1);
if (counter > 0) then
    -- 锁重入计数减1后还大于0：表明当前线程持有的锁还有重入，不能进行锁删除操作，但可以友好地帮忙设置下过期时期
    redis.call('pexpire', KEYS[1], ARGV[2]);
    return 0;
else
    -- 锁重入计数已为0：间接表明锁已释放了。直接删除掉锁，并广播解锁消息，去唤醒那些争抢过锁但还处于阻塞中的线程
    redis.call('del', KEYS[1]);
    redis.call('publish', KEYS[2], ARGV[1]);
    return 1;
end;

解锁lua脚本过程如下:

2.PNG

redisson还支持递归锁。

一般情况，redis的分布式锁客户端上锁失败后，常用的做法是本地循环等待锁的释放。JAVA和C++都可以通过future来实现阻塞式的等待。
C++下用future实现的接口如下：

#include <uuid/uuid.h>
#include <unistd.h>
#include <functional>     // std::ref
#include <thread>         // std::thread
#include <future>         // std::promise, std::future

extern RedisProxy g_redis_proxy;

std::string get_sys_uuid()
{
    uuid_t uu;
    uuid_generate( uu );

    char buf[33]={0};
    for(int i=0;i<16;i++)
    {
        sprintf(buf+i*2,"%02x",uu[i]);
    }
    //printf("%s\n",buf);
    return string(buf);
}

std::string g_sys_uuid=get_sys_uuid();

/*
*key number:1
*KEYS[1]: lock_name
*ARGV[1]: lock ttl
*ARGV[2]: key id
*return value: 0 - ok, >0 - fail
*/
const std::string lua_lock_cript="\
-- 若锁不存在：则新增锁，并设置锁重入计数为1、设置锁过期时间\
if (redis.call('exists', KEYS[1]) == 0) then\
    redis.call('hset', KEYS[1], ARGV[2], 1);\
    redis.call('pexpire', KEYS[1], ARGV[1]);\
    return nil;\
end;\
 \
-- 若锁存在，且唯一标识也匹配：则表明当前加锁请求为锁重入请求，故锁重入计数+1，并再次设置锁过期时间\
if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then\
    redis.call('hincrby', KEYS[1], ARGV[2], 1);\
    redis.call('pexpire', KEYS[1], ARGV[1]);\
    return nil;\
end;\
 \
-- 若锁存在，但唯一标识不匹配：表明锁是被其他线程占用，当前线程无权解他人的锁，直接返回锁剩余过期时间\
return redis.call('pttl', KEYS[1]);\
";

/*
*key number:2
*KEYS[1]: lock_name
*KEYS[2]: pub_chan_name,would be: hd_dlock_chan:${lock_name}
*ARGV[1]: publish content. 0 - unlock
*ARGV[2]: lock ttl
*ARGV[3]: key id
*/
const std::string lua_unlock_cript="\
-- 若锁不存在：则直接广播解锁消息，并返回1\
if (redis.call('exists', KEYS[1]) == 0) then\
    redis.call('publish', KEYS[2], ARGV[1]);\
    return 1;\
end;\
 \
-- 若锁存在，但唯一标识不匹配：则表明锁被其他线程占用，当前线程不允许解锁其他线程持有的锁\
if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then\
    return nil;\
end;\
\
-- 若锁存在，且唯一标识匹配：则先将锁重入计数减1\
local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1);\
if (counter > 0) then\
    -- 锁重入计数减1后还大于0：表明当前线程持有的锁还有重入，不能进行锁删除操作，但可以友好地帮忙设置下过期时期\
    redis.call('pexpire', KEYS[1], ARGV[2]);\
    return 0;\
else\
    -- 锁重入计数已为0：间接表明锁已释放了。直接删除掉锁，并广播解锁消息，去唤醒那些争抢过锁但还处于阻塞中的线程\
    redis.call('del', KEYS[1]);\
    redis.call('publish', KEYS[2], ARGV[1]);\
    return 1;\
end;\
";

const std::string HD_DLOCK_PUB_CHAN_PRE="hd_dlock_chan:";

int dlock_subscribe(std::string chan)
{
    return g_redis_proxy.subscribe(chan);
}

int try_lock(std::string &lock_name, int ttl, int timeout)
{
    if(timeout<=0||ttl<0) {return -1;}
    uint64 howlong=0;

    do{
        uint64 t1=get_millisecond();
        std::string key_id=g_sys_uuid+to_string(getpid());
        int ret=g_redis_proxy.eval3(lua_lock_cript,1,lock_name,to_string(ttl),key_id);
        if(ret==0)
        {
            
            return 0;
        }
        uint64 t2=get_millisecond();
        howlong+=t2-t1;

        if(howlong>=timeout) {return -1;}
        
        std::chrono::milliseconds span(1000*(timeout-howlong));
        std::string pub_chan=HD_DLOCK_PUB_CHAN_PRE+lock_name;
        std::future<int> fut = std::async(dlock_subscribe, pub_chan);

        // timeout, no one release lock
        if(fut.wait_for(span) == std::future_status::timeout)
        {
            g_redis_proxy.unsubscribe(pub_chan);
            return -1;
        }
        //else someone release lock

        ret = fut.get(); //must be 0,because we send 0 only
        
        uint64 t3=get_millisecond();
        howlong+=t3-t2;
    }while(1);

}

int unlock(std::string &lock_name,int ttl)
{
    std::string key_id=g_sys_uuid+to_string(getpid());
    std::string pub_chan=HD_DLOCK_PUB_CHAN_PRE+lock_name;
    
    int ret=g_redis_proxy.eval5(lua_unlock_cript,2,lock_name,pub_chan,to_string(0),to_string(ttl),key_id);
    return ret;
}