一、背景描述
最近遇到了，关于存在定时任务的项目在集群环境下部署如何解决重复执行的问题.
PS：
定时任务与项目没有拆分。
概述：之前的项目都是单机器部署，所以定时任务不会重复消费，只会执行一次。而在集群环境部署下，比如两台机器部署了当前的项目，如果不做任何处理的话势必会执行两次，通常重复执行会影响现有数据。所以要解决的就是在某个时间点，只能让一个项目执行这个定时任务。
考察知识点：分布式锁。
二、正文部分
这个问题最简单的操作方式是啥？
答：那就是一个打包带定时任务，一个打包不带定时任务...
咳咳，开个玩笑。显然这样不行啊，要是用这种操作先不说后面升级时每次打两个包多麻烦，单说这种方式就完全失去了集群部署的意义... 存在单点故障。
如果能找到唯一值的话，其实也是一种解决思路，比如可以通过数据库的唯一索引、或者主键索引来实现等。
下文则主要通过找不到唯一值的情况进行分析。
实现思路：数据库行级锁、redis分布式锁。
前面不是写过 Redis 分布式锁的文章吗，这次正好实践一下。
所以这次的技术选型就用 Redis 分布式锁来解决集群模式下定时任务重复执行的问题。
Redis 分布式锁有两种实现方式，一种是 Redisson+RLock，另一种是 SetNX+Lua脚本实现。
如果不了解的可以看一下下面这两篇文章，内含源码，本文皆以该源码操作。
Redis分布式锁—SETNX+Lua脚本实现篇
Redis分布式锁—Redisson+RLock可重入锁实现篇
简单分析：
这两篇 Redis 分布式锁的 demo，主要就是为了解决，在分布式部署中的商品接口避免超卖的情况。简单点说就是，无论用户的下单请求落在哪个服务实例上，首先你要保证顺序性，也就是你不能两个实例的同一方法同时执行业务逻辑，而是同一时间内只能由一个实例完成操作(减库存操作)；一个实例完成操作，则另一个才正常往下走。
和定时任务重复执行的问题有点类似了，但是与本文模拟的例子还是有一点点区别的，一个实例执行了定时任务，而另一个实例的定时任务是不能再继续执行业务代码的，因为换做以前可以通过商品的库存来进行判断，然后return掉，但是现在的情况是找不到唯一值，或者说找不到判定的条件，如果直接套上之前的代码，那么是没法阻止另一个实例定时任务执行的。
如下是之前 RLock 示例，用户下单的方法：
这里面有个判断库存的地方，大家可以看一下注释，定时任务遇到的问题。
@Transactional(rollbackFor = Exception.class)
public boolean createOrder(String userId, String productId) {
/** 如果不加锁，必然超卖 **/
RLock lock = redissonClient.getLock("stock:" + productId);
try {
/** 这一步相当于锁住，串连 **/
lock.lock(10, TimeUnit.SECONDS);
* 第一个实例执行完或者说锁在10秒后释放后，第二个实例永远也会走到下面这一步
* 无非就是在之前的例子中可以判断库存的形式进行返回，但是定时任务不行，
* 商品可以通过库存来判断，但是定时任务做不到，
* 所以加下来就是对当前这段代码进行改造。
int stock = stockService.get(productId).getStockNum();
log.info("剩余库存：{}", stock);
if (stock <= 0) {
return false;
String orderNo = UUID.randomUUID().toString().replace("-", "").toUpperCase();
/** 减库存操作 **/
if (stockService.decrease(productId)) {
Order order = new Order();
order.setUserId(userId);
order.setProductId(productId);
order.setOrderNo(orderNo);
Date now = new Date();
order.setCreateTime(now);
order.setUpdateTime(now);
orderDao.save(order);
return true;
} catch (Exception ex) {
log.error("下单失败", ex);
} finally {
lock.unlock();
return false;
}
2.1、SETNX+Lua脚本实现篇
至于 Lua 脚本怎么写的我就不在这赘述了，大家可以翻看上面的文章链接。
直接从代码下手，没什么变化，方法后面说一下过程。
@Scheduled(cron = "0 47 23 * * ?")
public void generateData() {
/** 定时任务的名称作为key **/
String key = "generateData";
/** 设置随机key **/
String value = UUID.randomUUID().toString().replace("-", "");
* setIfAbsent <=> SET key value [NX] [XX] [EX <seconds>] [PX [millseconds]]
* set expire time 20 s
Boolean flag = redisTemplate.opsForValue().setIfAbsent(key, value, 20000, TimeUnit.MILLISECONDS);
if (flag != null && flag) {
log.info("{} 锁定成功，开始处理业务", key);
try {
/** 模拟处理业务逻辑，15秒 **/
Thread.sleep(1000 * 15);
} catch (InterruptedException e) {
e.printStackTrace();
* 业务逻辑处理完毕，释放锁，正常情况下，由于上边 setIfAbsent 已经设置过期时间了，
* 所以在规定时间内，Redis 会自动删除过期的 key，但是这个删除由于不确实是什么删除策略，
* 所以最后执行完再删除一遍比较保险。
String lockValue = (String) redisTemplate.opsForValue().get(key);
/** 只有：值未被释放(也就是当前未达到过期时间)，且是自己加锁设置的值(不要释放别人的所)，这种情况下才会释放锁 **/
if (lockValue != null && lockValue.equals(value)) {
System.out.println("lockValue========：" + lockValue);
List<String> keys = new ArrayList<>();
keys.add(key);
Long execute = redisTemplate.execute(script, keys, lockValue);
System.out.println("execute执行结果，1表示执行del，0表示未执行 ===== " + execute);
log.info("{} 解锁成功，结束处理业务", key);
} else {
log.info("{} 获取锁失败", key);
}
首先方法顶部是一个 cron 的表达式，在每天的 23 点 47 分执行。
核心部分仍是 setIfAbsent() 方法，在这设置了一个 20 秒的过期时间，过期时间一到，默认会对 key 进行删除操作。
这个方法是个原子操作，所以两个实例同时执行的话，会产生锁竞争，返回的 Boolean 类型的 flag 即表示加锁状态。
为 true 表示获取锁成功，则另一个实例，或者另外所有的实例都会获取锁失败，即 flag = false 走 else 逻辑。
中间模拟了个 15 秒的业务执行，如果业务逻辑执行时间超过设置的 key 的过期时间，则 redisTemplate.opsForValue().get(key) 拿到的可能为 null 或者不一定为 null，为 null 说明 redis 自动触发了删除操作，不为 null 则虽然 key 值过期了，但是并没有立刻删除。
所以这种情况就需要删除一下。
删除也是一个小的细节，怎么讲？代码删除之前一定要判断是否是当前线程设置的 value，否则会出现释放别的线程锁的情况。
这个地方可能比较绕。
举个例子
：比如A、B线程同时进入该方法执行，从 setIfAbsent() 方法加锁，到处理业务业务代码15秒一切都很正常，此过程也只会有一个线程获得锁，另一个线程有 else 操作。但是需要注意的是，你没法保证两个定时任务同时执行，？？？因为你无法保证两台机器的时间永远一直，也就是会出现误差，这种情况就很恶心了，所以在设置 value 的时候用的是随机参数，这有个好处就是在删除之前先从 redis 再查询一遍，一致就删除释放锁，不一致就不释放。
2.2、Redisson + RLock
上面的问题代码贴过了，修改后如下：
@Scheduled(cron = "0 21 14 * * ?")
public void test(){
RLock lock = redissonClient.getLock("test");
/** 加锁状态 **/
boolean flag = false;
try {
flag = lock.tryLock(10,20, TimeUnit.SECONDS);
if(flag){
log.info("加锁成功，开始执行业务");
try {
log.info("模拟处理业务逻辑");
/** 模拟处理业务逻辑，15秒 **/
Thread.sleep(1000 * 15);
} catch (InterruptedException e) {
e.printStackTrace();
}else{
log.info("加锁失败，没有获取到锁");
} catch (Exception ex) {
log.error("下单失败", ex);
} finally {
if(!flag){
return;
lock.unlock();
log.info("Redisson分布式锁释放锁");
}
简单分析一下代码。
核心代码主要是 lock.tryLock(0,20, TimeUnit.SECONDS)，tryLock 方法有好几个重载方法，在上篇 [Redisson + RLock] 分布式锁中有写过，而今天我们用的是带三个参数的 tryLock。
/**
* 这里比上面多一个参数，多添加一个锁的有效时间
* @param waitTime 等待时间
* @param leaseTime 锁有效时间
* @param unit 时间单位 小时、分、秒、毫秒等
