【spring boot】【redis】spring boot基于redis的LUA脚本 实现分布式锁

spring boot基于redis的LUA脚本 实现分布式锁【都是基于redis单点下】

一.spring boot 1.5.X 基于redis 的 lua脚本实现分布式锁

1.pom.xml

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

2.RedisLock 工具类 （注入spring）

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import java.util.Collections;


/**
 *  spring boot 1.5.X
 * 使用redis 的 lua脚本  基于单点实现分布式锁
 *
 * lua脚本作为原子性操作，保证加锁和设置超时时间 为原子性操作
 * @author sxd
 * @date 2019/5/27 10:52
 */
@Component
public class RedisLock {

    @Autowired
    RedisTemplate redisTemplate;

    private static final Long SUCCESS = 1L;

    /**
     * 获取锁
     *
     * @param lockKey       redis的key
     * @param value         redis的value要求是随机串，防止释放其他请求的锁
     * @param expireTime    redis的key 的过期时间  防止死锁，导致其他请求无法正常执行业务
     * @return
     */
    public  boolean lock(String lockKey, String value, int expireTime) {

        String 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";

        RedisScript<String> redisScript = new DefaultRedisScript<>(script, String.class);

        //对非string类型的序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        Object result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey), value, String.valueOf(expireTime));

        return SUCCESS.equals(result);

    }

    /**
     * 释放锁
     *
     * @param lockKey   redis的key
     * @param value     redis的value  只有value比对一致，才能确定是本请求 加的锁 才能正常释放
     * @return
     */
    public  boolean unlock(String lockKey, String value) {

        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";

        RedisScript<String> redisScript = new DefaultRedisScript<>(script, String.class);

        try {
            Object result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey), value);
            if (SUCCESS.equals(result)) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

}

3.controller使用

/**
     * 使用分布式锁 逻辑
     * 1.准备好 key  value  expireTime
     * value要求是随机字符串
     * expireTime 是根据业务 衡量决定的 锁过期时间
     *
     * 2.获取锁
     * 成功获取，则执行业务，执行完成，释放锁
     * 失败获取，则重试获取，注意获取锁的时间间隔，直到获取成功，执行业务，最后释放锁
     *
     * 注意：
     *     对于redis加锁的业务，尽量用在耗时短的业务上。
     *
     */
    @RequestMapping("/test")
    public void test(){
        boolean flag = false; //标识  是否正常获取锁
        String uuid = UUID.randomUUID().toString(); //redis的value  是一串随机数
        flag = lock.lock("mykey1",uuid,5);
        if (flag){
            business(uuid);
        }else {

            //如果未正常获取锁  可以通过重试 直到获取锁成功
            while (!flag){
                try {

                    //重试 时间间隔  减少与redis交互次数
                    Thread.sleep(3000);
                    System.out.println("重试");
                    flag = lock.lock("mykey1",uuid,5);
                    if (flag){
                        business(uuid);
                    }else {
                        continue;
                    }

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }

    public void business(String uuid){
        
        try {
            System.out.println("加锁成功，执行业务");
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            //业务执行完成  正常释放锁
            lock.unlock("mykey1",uuid);
        }
    }

二.spring boot 2.x 基于redis 的LUA脚本 实现分布式锁

1.pom.xml

<!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--spring2.0集成redis所需common-pool2-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.4.2</version>
        </dependency>
        <!-- 使用redis的LUA脚本 需要序列化操作的jar-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

2.替代SpringBoot自动配置的RedisTemplate的RedisConfig类

package com.sxd.swapping.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.io.Serializable;


/**
 * @author sxd
 * @date 2019/5/27 16:13
 */
/**
 * @Description Redis配置类，替代SpringBoot自动配置的RedisTemplate，参加RedisAutoConfiguration
 */
@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Serializable> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Serializable> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        //Jackson序列化器
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //字符串序列化器
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //普通Key设置为字符串序列化器
        template.setKeySerializer(stringRedisSerializer);
        //Hash结构的key设置为字符串序列化器
        template.setHashKeySerializer(stringRedisSerializer);
        //普通值和hash的值都设置为jackson序列化器
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

}

3.RedisLock工具类，自动注入Spring

package com.sxd.swapping.utils;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;

/**
 *
 * spring boot 2.x版本
 * @author sxd
 * @date 2019/5/27 16:11
 */
@Component
public class RedisLock2 {


    Logger  logger = Logger.getRootLogger();

    static final Long LOCK_SUCCESS = 1L;

    static final Long LOCK_EXPIRED = -1L;

    @Autowired
    RedisTemplate redisTemplate;

    //定义获取锁的lua脚本
    private final static DefaultRedisScript<Long> LOCK_LUA_SCRIPT = new DefaultRedisScript<>(
            "if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then return redis.call('pexpire', KEYS[1], ARGV[2]) else return 0 end"
            , Long.class
    );



    //定义释放锁的lua脚本
    private final static DefaultRedisScript<Long> UNLOCK_LUA_SCRIPT = new DefaultRedisScript<>(
            "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return -1 end"
            , Long.class
    );



    /**
     * 加锁
     * @param key redis键值对 的 key
     * @param value redis键值对 的 value  随机串作为值
     * @param timeout redis键值对 的 过期时间   pexpire 以毫秒为单位
     * @param retryTimes 重试次数   即加锁失败之后的重试次数，根据业务设置大小
     * @return
     */
    public boolean lock(String key,String value ,long timeout, int retryTimes) {
        try {

            logger.debug("加锁信息：lock :::: redisKey = " + key + " requestid = " + value);
            //组装lua脚本参数
            List<String> keys = Arrays.asList(key);
            //执行脚本
            Object result = redisTemplate.execute(LOCK_LUA_SCRIPT, keys,value,timeout);
            //存储本地变量
            if(LOCK_SUCCESS.equals(result)) {

                logger.info("成功加锁：success to acquire lock:" + Thread.currentThread().getName() + ", Status code reply:" + result);
                return true;
            } else if (retryTimes == 0) {
                //重试次数为0直接返回失败
                return false;
            } else {
                //重试获取锁
                logger.info("重试加锁：retry to acquire lock:" + Thread.currentThread().getName() + ", Status code reply:" + result);
                int count = 0;
                while(true) {
                    try {
                        //休眠一定时间后再获取锁，这里时间可以通过外部设置
                        Thread.sleep(100);
                        result = redisTemplate.execute(LOCK_LUA_SCRIPT, keys);
                        if(LOCK_SUCCESS.equals(result)) {

                            logger.info("成功加锁：success to acquire lock:" + Thread.currentThread().getName() + ", Status code reply:" + result);
                            return true;
                        } else {
                            count++;
                            if (retryTimes == count) {
                                logger.info("加锁失败：fail to acquire lock for " + Thread.currentThread().getName() + ", Status code reply:" + result);
                                return false;
                            } else {
                                logger.warn(count + " times try to acquire lock for " + Thread.currentThread().getName() + ", Status code reply:" + result);
                                continue;
                            }
                        }
                    } catch (Exception e) {
                        logger.error("加锁异常：acquire redis occured an exception:" + Thread.currentThread().getName(), e);
                        break;
                    }
                }
            }
        } catch (Exception e1) {
            logger.error("加锁异常：acquire redis occured an exception:" + Thread.currentThread().getName(), e1);
        }
        return false;
    }








    /**
     * 释放KEY
     * @param key   释放本请求对应的锁的key
     * @param value 释放本请求对应的锁的value  是不重复随即串 用于比较，以免释放别的线程的锁
     * @return
     */
    public boolean unlock(String key,String value) {
        try {

            //组装lua脚本参数
            List<String> keys = Arrays.asList(key);
            logger.debug("解锁信息：unlock :::: redisKey = " + key + " requestid = " + value);
            // 使用lua脚本删除redis中匹配value的key，可以避免由于方法执行时间过长而redis锁自动过期失效的时候误删其他线程的锁

            Object result = redisTemplate.execute(UNLOCK_LUA_SCRIPT, keys, value);
            //如果这里抛异常，后续锁无法释放
            if (LOCK_SUCCESS.equals(result)) {
                logger.info("解锁成功：release lock success:" + Thread.currentThread().getName() + ", Status code reply=" + result);
                return true;
            } else if (LOCK_EXPIRED.equals(result)) {
                //返回-1说明获取到的KEY值与requestId不一致或者KEY不存在，可能已经过期或被其他线程加锁
                // 一般发生在key的过期时间短于业务处理时间，属于正常可接受情况
                logger.warn("解锁异常：release lock exception:" + Thread.currentThread().getName() + ", key has expired or released. Status code reply=" + result);
            } else {
                //其他情况，一般是删除KEY失败，返回0
                logger.error("解锁失败：release lock failed:" + Thread.currentThread().getName() + ", del key failed. Status code reply=" + result);
            }
        } catch (Exception e) {
            logger.error("解锁异常：release lock occured an exception", e);
        }

        return false;
    }





}

4.使用

 @Autowired
    RedisLock2 lock2;

    @Autowired
    RedisTemplate redisTemplate;


    @RequestMapping("/test3")
    public void test3(){
        ValueOperations vops = redisTemplate.opsForValue();
        String uuid = UUID.randomUUID().toString();

        //加锁
        if (lock2.lock("mykey1",uuid,5000,3)){

            try {
//                执行业务
                System.out.println("加锁成功，做业务");

                vops.increment(REDIS_COUNT_KEY,1);
                Thread.sleep(3000);

                System.out.println("业务执行结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                //解锁
                lock2.unlock("mykey1",uuid);
            }
        }
    }