Redis分布式锁

目前几种分布式锁的实现方式：

• 数据库实现（不适合数据量比较大的互联网公司）、
• 基于ZK的实现（1、Zk的节点改变时候的watcher事件通知。2、节点类型中的有序节点可实现先到先得公平策略）
• 基于Redis的实现（setNX + 有效期，实现相对ZK简单一些）　　　　

工作中经常用到Redis，所以决定采用redis实现分布式锁, 首先先要明确目标，目标明确了才有技术方案

分布式锁实现的目标：

•  高性能（加锁和解锁性能高）
•  互斥访问（一个线程持有锁，另一个线程不能持有）
•  不能产生死锁（例如redis客户端挂了，或者设置过期时间时候挂了导致key永久有效）
•   解锁（只能解除自己的锁）

具体实现：

package com.brightcns.wuxi.citizencard.common.feature.util;

import javafx.beans.binding.ObjectExpression;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.util.SafeEncoder;


/**
 * 分布式锁的常用类
 * @author maxianming
 * @date 2018/8/13 15:50
 */
@Slf4j
public class LockUtils {

    private JedisConnectionFactory jedisConnectionFactory;
    private static final Long RELEASE_SUCCESS = 1L;
    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";

    public LockUtils(JedisConnectionFactory jedisConnectionFactory) {
        if (jedisConnectionFactory == null) {
          throw new IllegalArgumentException("jedisConnectionFactory not be allowed null");
        }
        this.jedisConnectionFactory = jedisConnectionFactory;
    }
    /**
     * 尝试获取分布式锁
     * @param lockKey 锁
     * @param requestId 请求标识
     * @param expireTime 超期时间 ms
     * @return 是否获取成功
     */
    public void lock(String lockKey, String requestId, int expireTime) throws InterruptedException {
        RedisConnection redisConnection = getRedisConnection();
        try {
          while (true) {
               Object result = redisConnection.execute("SET", new byte[][]{
                       SafeEncoder.encode(lockKey), SafeEncoder.encode(requestId), SafeEncoder.encode(SET_IF_NOT_EXIST),
                       SafeEncoder.encode(SET_WITH_EXPIRE_TIME), SafeEncoder.encode(String.valueOf(expireTime))});
               if (result != null) {
                   if (LOCK_SUCCESS.equals(new String((byte[])(result)))) {
                       return;
                   }
               }
              try {
                  Thread.sleep(expireTime);
              } catch (InterruptedException e) {
                  log.error("中断异常", e);
                  throw e;
              }
          }
       } finally {
           redisConnection.close();
       }
    }


    /**
     * 释放分布式锁
     * @param lockKey 锁
     * @param requestId 请求标识
     * @return 是否释放成功
     */
    public boolean unLock(String lockKey, String requestId) {
        RedisConnection redisConnection = getRedisConnection();
        try {
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            Object result = redisConnection.eval(SafeEncoder.encode(script), ReturnType.INTEGER, 1, getByteParams(new String[]{lockKey, requestId}));
            if (RELEASE_SUCCESS.equals(result)) {
                return true;
            }
            return false;
        } finally {
            redisConnection.close();
        }

    }

    private byte[][] getByteParams(String... params) {
        byte[][] p = new byte[params.length][];
        for (int i = 0; i < params.length; i++)
            p[i] = SafeEncoder.encode(params[i]);

        return p;
    }

    private RedisConnection getRedisConnection() {
        RedisConnection redisConnection = jedisConnectionFactory.getConnection();
        return redisConnection;
    }

    public static void main(String[] args) {
       JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setPort(6379);
        jedisConnectionFactory.setHostName("*");
        jedisConnectionFactory.setPassword("*");

        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(40);
        poolConfig.setMaxIdle(10);
        poolConfig.setMinIdle(5);
        jedisConnectionFactory.setPoolConfig(poolConfig);
        jedisConnectionFactory.afterPropertiesSet();
        LockUtils lockUtils =new LockUtils(jedisConnectionFactory);
        Thread thread = new Thread(() -> {
            try {
                lockUtils.lock("lock", "123", 20000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("加锁结果:" + "成功");

            boolean result = lockUtils.unLock("lock", "123");

            System.out.println("解锁结果:" + result);
        },"jedis-thread");
        thread.start();
    }

}

   （1）加锁

           jedis提供了set方法将setNX和expire整合在一起的原子方法，这就避免了expire之前redis挂了导致的key永久有效，从而死锁。

          实际项目中使用的Spring boot整合的redis，所以直接获取jedis客户端不太方便，查看源码发现 存在execute支持redis命令。

          requestId的作用，解锁的时候传入加锁时候的相同值，避免错误解除别的线程的锁

          expireTime的作用，redis key的有效期，根据实际时间设置

 （2）解锁

          采用lua脚本，主要保证一、解锁操作的原子性 二、解的是自己的锁