Redis实现分布式锁

需求

　　最近负责的一个项目是微服务开发，我所开发的服务里有个定时任务，如果在集群环境下仅仅使用@scheduled，会发生定时任务幂等的问题。

　　可以采取的解决方案：

　　1.通过在配置文件设置定时任务开关，只允许一台开启定时任务。考虑到使用了nacos作为配置中心，单节点定时任务对单台服务器的压力以及单点故障问题，不采用。

　　2.搭建一套分布式任务调度系统。考虑到时间紧急及目前定时任务比较少，不采用。

　　3.使用分布式锁。由于项目本身就使用到redis，而且开发成本低，采用。

分布式锁介绍

　　什么是分布式锁？

　　分布式锁是控制分布式系统之间共同访问共享资源的⼀种锁实现

　　为什么要用分布式锁？

　　在单节点系统中，我们可以通过synchronized和lock保证同⼀个⽅法在同一个时刻被同一个线程调用。但是在分布式系统中，这就不管用了，因此，我们使用分布式锁的目的是保证在分布式部署的应⽤集群中，同⼀个⽅法在同⼀时刻只能被⼀台机器上的⼀个线程执⾏。就像需求中提到到，同一时刻只有一台机子在执行定时任务。

实现原理和思路

　　原理：通过Redis的setnx key value命令，当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。

　　思路：

　　1.获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，避免宕机或网络原因发生导致锁不能释放发生死锁。

　　2.锁的value值为当前服务器的ip+端口(考虑在定时任务中使用)，大家也可以用UUID，在释放锁的时候进行判断，避免释放到不属于自己的锁。

代码实现（基于SpringBoot2.0开发）

　　第一步：Maven依赖

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

　　第二步：Redis参数配置

　　在application.properties中添加redis的链接地址

spring.redis.database = 0
spring.redis.host = 127.0.0.1
spring.redis.port = 6379
spring.redis.password =

　　创建RedisConfig

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    @Bean
    public KeyGenerator simpleKeyGenerator() {
        return (o, method, objects) -> {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(o.getClass().getSimpleName());
            stringBuilder.append(".");
            stringBuilder.append(method.getName());
            stringBuilder.append("[");
            for (Object obj : objects) {
                stringBuilder.append(obj.toString());
            }
            stringBuilder.append("]");

            return stringBuilder.toString();
        };
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return new RedisCacheManager(
                RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                this.getRedisCacheConfigurationWithTtl(600), 
                this.getRedisCacheConfigurationMap() 
        );
    }

    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
        redisCacheConfigurationMap.put("UserInfoList", this.getRedisCacheConfigurationWithTtl(100));
        redisCacheConfigurationMap.put("UserInfoListAnother", this.getRedisCacheConfigurationWithTtl(18000));

        return redisCacheConfigurationMap;
    }

    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        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);

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                RedisSerializationContext
                        .SerializationPair
                        .fromSerializer(jackson2JsonRedisSerializer)
        ).entryTtl(Duration.ofSeconds(seconds));

        return redisCacheConfiguration;
    }

}

　　第三步：创建RedisService，实现加锁与释放，加锁的过程不是原子操作，理论上会发生上锁成功但是没有设置过期时间的可能，这里改进的话可以使用Lua脚本来保证原子性操作。

@Service
public class RedisService {

    @Autowired
    private RedisTemplate redisTemplate;


    /**
     * 获取分布式锁
     *
     * @param lockName  锁名称
     * @param lockValue 锁值
     * @param lockValue 过期时间
     * @return
     */
    public boolean lock(String lockName, String lockValue, Long expireTime) {
        boolean result = false;
        try {
            result = redisTemplate.opsForValue().setIfAbsent(lockName, lockValue);
            if (result) {
                redisTemplate.expire(lockName, expireTime, TimeUnit.SECONDS);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 释放分布式锁
     *
     * @param lockName  锁名称
     * @param lockValue 锁值
     * @return
     */
    public boolean release(String lockName, String lockValue) {
        boolean result = false;
        try {
            if (lockValue.equals(redisTemplate.opsForValue().get(lockName))) {
                return redisTemplate.delete(lockName);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

}

　　第四步:代码测试

@Service
@Slf4j
public class MyLockJob {

    private static String LOCK_NAME = "my_lock";

    @Value("${server.port}")
    private String serverPort;
    @Autowired
    private RedisService redisService;


    @Scheduled(cron = "0/9 * * * * *")
    public void lockJob() throws Exception {
        boolean lockResult = false;
        try {

            String lockValue = InetAddress.getLocalHost().getHostAddress() + ":" + serverPort;
            lockResult = redisService.lock(LOCK_NAME, lockValue, 10L);

            // 获取锁成功
            if (lockResult) {
                log.info("地址：" + InetAddress.getLocalHost().getHostAddress() + ":" + serverPort + "获取锁成功!");
                Thread.sleep(5000);
                return;
            }
        } catch (Exception e) {
            log.error("lock error", e);
        } finally {
            // 根据锁的名称及锁的值释放锁
            if (lockResult) {
                String releaseValue = InetAddress.getLocalHost().getHostAddress() + ":" + serverPort;
                boolean releaseResult = redisService.release(LOCK_NAME, releaseValue);
                if (releaseResult) {
                    log.info(InetAddress.getLocalHost().getHostAddress() + ":" + serverPort + "释放锁成功!");
                }
            }
        }
    }

}

结果展示

　　本地起了四台服务8080~8083，模拟多台服务器争抢锁及释放锁的过程，这里展示一分钟内获取锁和释放锁的情况。

　　8080端口获取锁：

　　8081端口获取锁：

　　8082端口有点倒霉，没拿到锁。

　　8083端口获取锁：

 　　可以看到，同一时刻，只有一个服务能拿到锁，并且获取锁及释放锁为同一服务，需求完成。