Redis实现分布式锁

实现目标

• 多个客户端互斥获得锁
• 避免死锁
• 解锁需要加锁的客户端

实现思路

以一个redis key作为锁，多个客户端并发竞争此锁。如果key不在redis中或已经过期，执行set if not exist尝试向redis插入key为键，能标识客户端的值为value(可以随机生成，后续解锁使用)的数据，并设置过期时间防止死锁，这一操作代表此客户端获得了锁。完成业务逻辑后删除key作为释放锁；如果执行set if not exist返回失败，则表示已有客户端获得了锁。

java代码实例

redis客户端采用jedis。释放锁的代码使用了lua脚本保证释放锁的过程具备原子性。
main()方法开启大量线程模拟客户端请求，请求的最终目标当然是希望能获得锁，因此使用一个变量testSuccessCnt记录成功获得锁的线程数量。测试结果与期望一致。

@Slf4j
public class RedisTool {

    private static final String LOCK_SUCCESS = "OK";

    private static final String SET_IF_NOT_EXIST = "NX";

    private static final String SET_WITH_EXPIRE_TIME = "PX";

    private static final Long RELEASE_SUCCESS = 1L;

    private static AtomicInteger testSuccessCnt = new AtomicInteger(0);


    /**
     * 尝试获取分布式锁
     * @param jedis Redis客户端
     * @param lockKey 锁
     * @param requestId 请求标识
     * @param expireTime 超期时间
     * @return 是否获取成功
     */
    public static boolean tryGetDistributedLock(Jedis jedis, String lockKey, String requestId, int expireTime) {

        String result = jedis.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime);

        return LOCK_SUCCESS.equals(result);

    }

    /**
     * 释放分布式锁
     * @param jedis Redis客户端
     * @param lockKey 锁
     * @param requestId 请求标识
     * @return 是否释放成功
     */
    public static boolean releaseDistributedLock(Jedis jedis, String lockKey, String requestId) {

        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        Object result = jedis.eval(script, Collections.singletonList(lockKey), Collections.singletonList(requestId));

        return RELEASE_SUCCESS.equals(result);

    }


    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            doRequest();
        }

        log.info("test acquire distribute lock success count is {}", testSuccessCnt);
    }

    private static void doRequest() {
        final Jedis jedis = new Jedis("localhost", 6379);
        final String key = "distributeKey";
        final String requestId = UUID.randomUUID().toString();
        final int expiredTime = 1;


        new Thread() {
            @Override
            public void run() {
                boolean success = tryGetDistributedLock(jedis, key, requestId, expiredTime);
                log.info("客户端{}获取分布式锁结果{}", requestId, success);

                if (success) {
                    // 模拟执行任务若干秒
                    try {
                        Thread.currentThread().sleep(Math.abs(new Random(100).nextInt(10)));
                    } catch (InterruptedException e) {
                        log.error("线程被中断");
                        e.printStackTrace();
                    }
                    testSuccessCnt.addAndGet(1);
                    log.info(">>>>>" + testSuccessCnt.toString());

                    boolean release = releaseDistributedLock(jedis, key, requestId);
                    log.info("客户端{}释放分布式锁结果{}", requestId, release);
                } else {
                    run();
                }

            }
        }.start();
    }
}