Redis5.0+——分布式锁（带SpringBoot测试案例）

需求分析：

由于分布式系统多线程的特点以及分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，单纯的 Java API 并不能提供分布式锁的能力。为了解决这个问题就需要一种跨 JVM 的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题！

如何实现

1.通过命令setnx实现

127.0.0.1:6380> setnx users 10 # 开启锁
127.0.0.1:6380> setnx users 20 #再次设置值失败
(integer) 0
# 上锁以后如何释放锁？
127.0.0.1:6380>del users

2.若某个锁一直没有释放如何解决？

一般可以设置过期时间

setnx users 10
expire users 10#设置过期时间10秒
ttl users # 查看key过期时间

3.上锁之后突然出现异常，无法设置过期时间了，如何解决？

上锁的同时设置过期时间就可以了

127.0.0.1:6380>set users 10 nx ex 12 # 代表给users这个key，nx设置加锁，ex设置过期时间12秒

4.锁可能被误删，如何解决？

优化分布式锁加上UUID

set lock uuid ux ex 10 #释放锁时，先判断当前uuid和要释放锁的uuid是否一样

SpringBoot代码实现锁

pom文件

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

yml文件

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0
    connect-timeout: 3000
    jedis:
      pool:
        max-active: 20
        max-wait: -1
        max-idle: 5
        min-idle: 0

配置类

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer 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);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
         template.setValueSerializer(jackson2JsonRedisSerializer);
    //value hashmap序列化
     template.setHashValueSerializer(jackson2JsonRedisSerializer);return template;}
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer 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);
        // 配置序列化（解决乱码的问题）,过期时间600秒
         RedisCacheConfiguration config = RedisCacheConfiguration
                 .defaultCacheConfig()
                 .entryTtl(Duration.ofSeconds(600))
                 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                 .serializeValuesWith(RedisSerializationContext.SerializationPair
                         .fromSerializer(jackson2JsonRedisSerializer)).disableCachingNullValues();
         RedisCacheManager cacheManager = RedisCacheManager.builder(factory).cacheDefaults(config).build();
         return cacheManager;
    }
}

测试类

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;
    @GetMapping("testLock")
    public void testLoack(){
        //通过UUID解决锁误删情形
        String uuid = UUID.randomUUID().toString();
        //1.获取锁，setIfAbsent等价redis的setxn,设置3秒过期时间
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid,3, TimeUnit.SECONDS);
        //获取锁成功、查询num的值
        if (lock){
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断num为空return
            if (StringUtils.isEmpty(value)){
                return;
            }
            //2.2有值就转成int
            int num = Integer.parseInt(value+"");
            //2.3把redis的num+1
            redisTemplate.opsForValue().set("num",++num);
            //2.4释放锁，del
            //释放之前判断uuid是否一致
            String lockUUID = (String) redisTemplate.opsForValue().get("lock");
            if (lockUUID.equals(uuid)){
                redisTemplate.delete("lock");
            }
        }else {
            //3.获取锁失败、每隔0.1秒再获取
            try{
                Thread.sleep(100);
                testLoack();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

使用lua脚本释放锁保证原子性

			//2.释放锁del
            String script = "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else retuen 0 end";
            //设置lua脚本返回的数据类型
            DefaultRedisScript<Object> redisScript = new DefaultRedisScript<>();
            //设置lua脚本返回类型为Long
            redisScript.setResultType(Long.class);
            redisScript.setScriptText(script);
            redisTemplate.execute(redisScript, Arrays.asList("lock"),uuid);