【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); } } }
