spring boot lua脚本实现redis分布式锁

一、maven坐标

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

二、加配置

spring:
  redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    password: 
    lettuce:
      pool:
        max-active: 8
        max-wait: -1
        min-idle: 0
      shutdown-timeout:   100 

三、实现锁

import java.util.Collections;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;

import com.hbhtxx.common.core.util.IdUtil;

import lombok.extern.slf4j.Slf4j;


/**
 * 
 * @ClassName: RedisLock
 * @Description: lua脚本作为原子性操作，保证加锁和设置超时时间 为原子性操作
 * @author: He LongYun
 * @date: 2020年5月18日 下午2:08:40
 */
@Component
@Slf4j
public class RedisLock {

    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final Long SUCCESS = 1L;
//加锁脚本
    private static final String LOCK_SCRIPT =
            "if redis.call('setNx',KEYS[1],ARGV[1]) then if redis.call('get',KEYS[1])==ARGV[1] then return redis.call('expire',KEYS[1],ARGV[2]) else return 0 end end";
//解锁脚本
    private static final String UNLOCK_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";

    private ThreadLocal<String> threadLocal = new ThreadLocal<>();


    /**
     * 获取锁
     *
     * @param lockKey redis的key
     * @param expireTime redis的key 的过期时间 防止死锁，导致其他请求无法正常执行业务
     * @return
     */
    public boolean lock(String lockKey, int expireTime) {
        try {
            String value = IdUtil.fastSimpleUUID();
            threadLocal.set(value);
            RedisScript<Long> redisScript = new DefaultRedisScript<>(LOCK_SCRIPT, Long.class);
            // 对非string类型的序列化
            Object result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey), value, String.valueOf(expireTime));
            return SUCCESS.equals(result);
        } catch (Exception e) {
            // 任何异常都是加锁失败
            log.error("获取锁异常-----------------> e={}", e.getMessage());
            threadLocal.remove();
            return false;
        }

    }

    /**
     * 
     * @Title: tryLock
     * @Description: 获取锁
     * @param lockKey key
     * @param expireTime 过期时间(秒)
     * @param retryTimes 重试次数
     * @param sleepMillis 每次重试间隔时间(毫秒)
     * @return boolean
     * @author He LongYun
     * @date 2020年5月18日下午3:19:24
     */
    public boolean tryLock(String lockKey, int expireTime, int retryTimes, Long sleepMillis) {
        boolean result = lock(lockKey, expireTime);
        while ((!result) && retryTimes-- > 0) {
            try {
                log.debug("每次重试时间间隔-----> retryTimes={} ", retryTimes);
                Thread.sleep(sleepMillis);
            } catch (InterruptedException e) {
                return false;
            }
            result = lock(lockKey, expireTime);
        }
        return result;
    }

    /**
     * 释放锁
     *
     * @param lockKey redis的key
     * @return
     */
    public boolean unlock(String lockKey) {
        if (threadLocal.get() == null) {
            return true;
        }
        try {
            RedisScript<Long> redisScript = new DefaultRedisScript<>(UNLOCK_SCRIPT, Long.class);
            Object result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey), threadLocal.get());
            if (SUCCESS.equals(result)) {
                return true;
            }
            return false;
        } catch (Exception e) {
            return false;
        } finally {
            threadLocal.remove();
        }
    }

}

一般使用redis，都需要对key、value进行序列化，这里直接使用StringRedisTemplate，可以省去序列化配置（StringRedisTemplate是对String对RedisTemplate再次封装），有兴趣可以看一下StringRedisTemplate源码：

/**
	 * Constructs a new <code>StringRedisTemplate</code> instance. {@link #setConnectionFactory(RedisConnectionFactory)}
	 * and {@link #afterPropertiesSet()} still need to be called.
	 */
	public StringRedisTemplate() {
		RedisSerializer<String> stringSerializer = new StringRedisSerializer();
		setKeySerializer(stringSerializer);
		setValueSerializer(stringSerializer);
		setHashKeySerializer(stringSerializer);
		setHashValueSerializer(stringSerializer);
	}

四、测试

@RestController
@RequestMapping(("/test"))
@Slf4j
public class TestController {

    @Autowired
    private RedisLock redisLock;

    /**
     * 
     * @Title: lock
     * @Description: 测试加锁
     * @author He LongYun
     * @date 2020年5月20日下午3:42:09
     */
    @GetMapping(value = "/lock.do")
    public void lock() {
        String lockKey = "my:redis:lock:" + System.currentTimeMillis();
        boolean lock = false;
        try {
            lock = redisLock.lock(lockKey, 30);
            log.info("加锁----> lockKey={},lock={}", lockKey, lock);
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            if (lock) {
                // boolean unlock = redisLock.unlock(lockKey);
                // log.info("解锁----> lockKey={},unlock={}", lockKey, unlock);
            }
        }
    }
}

浏览器 http://ip:port/test/lock.do
1、连续多次，测试结果如下

2、打开 解锁注释

 boolean unlock = redisLock.unlock(lockKey);
 log.info("解锁----> lockKey={},unlock={}", lockKey, unlock);

五、以上只是简单测试，有兴趣可以进行压力测试，小编用JMeter测试过1000并发，可以通过的，下一篇用spring integration 实现分布式锁