mmall_v2.0 分布式锁实现定时关单

在电商项目中，用户购买商品在生成订单后，一定时间内如果没有付款，应该将订单关闭。这里，主要用 Spring Schedule 和分布式锁来实现，而分布式锁也分别用 Redis 命令原生实现和 Redisson 框架两种方式。

Spring Schedule 介绍

Spring Schedule 是一个任务调度框架，用于定时任务调度等。主要通过 @Scheduled 注解来创建定时任务，可通过 cron 表达式来指定任务特定的执行时间。

Cron 表达式

Cron 表达式是一个字符串，由 6 或 7 个字段组成，对应为 秒、分、时、日、月、周、年(可选)。

允许的值和特殊字符

特殊字符的含义

• * ：匹配任意值，例如秒域为 * 表示每秒都会触发事件；
• ? : 只能在月内第几天和周内第几天两个域使用，用于执行不明确的值。当两个域之一被指定值后，为避免冲突，需要将另一个的值设为 ? ；
• - : 指定一个范围，例如分域为 3-6 ，表示从 3 分到 6 分钟每分钟触发一次；
• / : 指定增量，表示起始时间开始触发，然后每隔固定时间触发一次，例如分域为 5/15 ，则意味着 5 分、 20 分、 35 分、 50 分，分别触发一次；
• , ：指定几个可选值。例如在分域使用 5,15 ，则意味着在 5 和 20 分各触发一次；
• L : 表示最后，只能出现在周内第几天和月内第几天域，表示一月的最后一天，或一周的最后一天。如果在周内第几天域前加上数字，表示一月的最后一个第几天。例如 5L 表示一个月的最后一个周五；
• W : 指定有效工作日(周一到周五)，只能在月内第几天域使用，系统将在离指定日期的最近的有效工作日触发。注意一点， W 的最近寻找不会跨过月份；
• LW : 两个字符可以连用，表示一月的最后一个工作日，即最后一个星期五。
• # : 指定一月的周内第几天，只能出现在月内第几天域。例如在 2#3 ，表示一月的第三个星期一( 2 表示周一， 3 表示第三周)。
• C ：可以在月内第几天和周内第几天使用。

举例

"0 1 * * * *"               表示每小时1分0秒执行一次

"*/20 * * * * *"            表示每20秒执行一次

"0 0 9-12 * * *"            表示每天9，10，11，12点执行一次

"0 0/20 9-12 * * *"         表示每天9点到12点，每20分钟执行一次

"0 0 9-12 * * 2-6"          表示每周一至周五，9点到12点的0分0秒执行一次

"0 0 0 1 4 ?"               表示4月1日0时0分0秒执行一次
复制代码

实现定时任务

首先，在 applicationContext.xml 文件中配置：

<task:annotation-driven/>
复制代码

开启定时任务。注意，导入约束时导入的是 http://www.springframework.org/schema/task 。

然后，创建定时关闭订单的 task ：

@Component
@Slf4j
public class CloseOrderTask {

    @Autowired
    private IOrderService iOrderService;

    @Scheduled(cron="0 */1 * * * ?")
    public void closeOrderTaskV1() {
        log.info("关闭订单定时任务启动");
        int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour", "1"));
        iOrderService.closeOrder(hour);
        log.info("关闭订单定时任务结束");
    }
}
复制代码

表示每隔一分钟就查看是否有超过一个小时的订单未付款，如果有则进行关闭。 IOrderServiceImpl 的 closeOrder 方法如下：

@Override
public void closeOrder(int hour) {
    Date closeDateTime = DateUtils.addHours(new Date(), -hour);
    List<Order> orderList = orderMapper.selectOrderStatusByCreateTime(Const.OrderStatusEnum.NO_PAY.getCode(), DateTimeUtil.dateToStr(closeDateTime));
    for (Order order : orderList) {
        List<OrderItem> orderItemList = orderItemMapper.getByOrderNo(order.getOrderNo());
        for (OrderItem orderItem : orderItemList) {
            Integer stock = productMapper.selectStockByProductId(orderItem.getId());
            if (stock == null) {
                continue;
            }
            Product product = new Product();
            product.setId(orderItem.getProductId());
            product.setStock(stock + orderItem.getQuantity());
            productMapper.updateByPrimaryKeySelective(product);
        }
        orderMapper.closeOrderByOrderId(order.getId());
        log.info("关闭订单OrderNo：{}", order.getOrderNo());
    }
}
复制代码

主要逻辑是，首先查询超过一个小时的订单列表，然后对列表中的每一条订单，根据订单号查询商品列表，对每一件商品的库存进行更新，最后，对订单的状态进行修改，即意味着删除。

如此，定时关闭一定时间内未付款的订单的 v1 版本就完成了。但是在 tomcat 集群环境下，每次只需要一台机器执行即可，不用每台机器都执行；而且，多台机器同时执行也容易造成数据错乱。所以，这就需要使用分布式锁来进行保证。

Redis 命令实现分布式锁

Redis 命令

下面是其中会用到的一下 Redis 命令：

1). setnx key value

SET if Not eXists 的简称。如果键不存在，则将键 key 的值设置为 value 。否则如果键已经存在，则不做任何操作。

设置成功时返回 1 ，设置失败时返回 0 。

2). getset key value

将键 key 的值设为 value ，并返回键 key 在被设置之前的旧值。

如果键 key 存在旧值，则会返回。否则如果不存在旧值，也就是键 key 在设置之前并不存在，则返回 nil 。

3). expire key seconds

为给定的键 key 设置生存时间，当 key 的生存时间为 0 (过期) 时，它会被自动删除。

4). del key [key...]

删除给定的一个或多个 key 。

Redis 分布式锁

Redis 分布式锁原理

Redis 分布式锁的流程图如下:

它的主要原理是：首先，通过 setnx 存入一个 lockkey ，如果设置成功，也就是获取锁成功，就为锁设置一个有效期，然后执行业务，之后将 lockkey 删除，最后将锁释放。如果设置失败，也就是获取锁失败，则直接结束。

这里使用 setnx 命令，开始时 Redis 中不存在 lockkey ， setnx(lockkey) 就会返回 1 ，表示本台机器获取到了锁，可以定时执行业务。而其他机器在有效期内获取锁时， lockkey 已经存在，就会返回 0 ，表示没有获取到锁，其他机器正在执行业务。

构建分布式任务调度

利用 Spring Schedule + Redis 分布式锁构建分布式任务调度，方法 closeOrderTaskV2 版本如下：

@Scheduled(cron = "0 */1 * * * ?")
public void closeOrderTaskV2() {
    log.info("关闭订单定时任务启动");
    long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout", "5000"));
    // 获取锁
    Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis() + lockTimeout));
    if (setnxResult != null && setnxResult.intValue() == 1) {
        // 如果返回值是 1，代表设置成功，获取锁
        closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
    } else {
        log.info("没有获取到分布式锁：{}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
    }
    log.info("关闭订单定时任务结束");
}

private void closeOrder(String lockName) {
    // 修改存活时间
    RedisShardedPoolUtil.expire(lockName, 5);
    log.info("获取{}, ThreadName:{}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, Thread.currentThread().getName());
    int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour", "2"));
    iOrderService.closeOrder(hour);
    // 删除 key
    RedisShardedPoolUtil.del(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
    log.info("释放{}, ThreadName:{}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, Thread.currentThread().getName());
}
复制代码

缺点

如果某台 tomcat 机器成功获取到锁，但在为锁设置有效期之前， tomcat 机器意外关闭，这时就会产生死锁。

可以在 CloseOrderTask 中添加一个 delLock 方法，在销毁之前删除分布式锁：

@PreDestroy
public void delLock() {
    RedisShardedPoolUtil.del(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
}
复制代码

但如果直接 kill 掉 tomcat 进程，仍然不会调用这个方法，从而产生死锁。

Redis 分布式锁双重防死锁

Redis 分布式锁优化原理

Redis 分布式锁优化后的流程图如下:

它的原理是：同样首先通过 setnx 存入一个 lockkey ，如果设置成功，同之前一样。否则，通过 get 获得之前设置的 currentTime + timeout ，判断 lockValeA 是否不为 null ，并且 currentTime 大于 lockValueA ，即分布式锁是否过期。

如果过期，通过 getset 将 lockkey 对应的 value 设置为 currentTime + timeout ，并得到之前的旧值 lockValueB ，判断 lockValueB 是否为 null ，即 lockkey 是否还存在，或者 lockValueA 是否等于 lockValueB ，即在这个过程中锁没有改变。如果条件满足，则表示获取锁成功，同 setnx 获取锁成功一样。

如果锁没有过期，则表示获取锁失败，直接结束。在 getset 后，如果 lockValueB 不为空，即 lockkey 仍然存在，或者锁被改变了，也表示获取锁失败，直接结束。

构建分布式任务调度

利用 Spring Schedule + Redis 分布式锁构建分布式任务调度，方法 closeOrderTaskV3 版本如下：

@Scheduled(cron = "0 */1 * * * ?")
public void closeOrderTaskV3() {
    log.info("关闭订单定时任务启动");
    long lockTimeout = Long.parseLong(PropertiesUtil.getProperty("lock.timeout", "5000"));
    // 获取锁
    Long setnxResult = RedisShardedPoolUtil.setnx(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis() + lockTimeout));
    if (setnxResult != null && setnxResult.intValue() == 1) {
        // 如果返回值是 1，代表设置成功，获取锁
        closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
    } else {
        // 未获取到锁，继续判断时间戳，看锁是否过期
        String lockValueStr = RedisShardedPoolUtil.get(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        if (lockValueStr != null && System.currentTimeMillis() > Long.parseLong(lockValueStr)) {
            // 锁过期，重置并获取锁
            String getSetResult = RedisShardedPoolUtil.getSet(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, String.valueOf(System.currentTimeMillis() + lockTimeout));
            if (getSetResult == null || (getSetResult != null && StringUtils.equals(lockValueStr, getSetResult))) {
                closeOrder(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            } else {
                log.info("没有获取到分布式锁：{}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
            }
        } else {
            log.info("没有获取到分布式锁：{}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
        }
    }

    log.info("关闭订单定时任务结束");
}
复制代码

Redisson 实现分布式锁

Redisson 是架设在 Redis 上的一个 Java 驻内存数据网格，它在基于 NIO 的 Netty 框架上，充分地利用了 Redis 键值数据库提供的一系列优势。

将 Redisson 集成到项目中，只需要在 pom.xml 文件需要添加 redisson 和 jackson-dataformat-avro 的依赖。

Redisson 初始化类

public class RedissonManager {

    private Config config = new Config();
    private Redisson redisson;

    private static String redis1IP = PropertiesUtil.getProperty("redis1.ip", "192.168.23.130");
    private static Integer redis1Port = Integer.parseInt(PropertiesUtil.getProperty("redis1.port", "6379"));

    @PostConstruct
    public void init() {
        try {
            config.useSingleServer().setAddress(redis1IP + ":" + redis1Port);
            redisson = (Redisson) Redisson.create(config);
            log.info("初始化 Redisson 结束");
        } catch (Exception e) {
            log.error("初始化 Redisson 失败", e);
        }
    }

    public Redisson getRedisson() {
        return redisson;
    }
}
复制代码

这里使用单服务器模式，在传入地址时采用 ip:port 格式。

任务调度 v4 版本

tryLock 方法在获取锁时，三个参数分别为：尝试获取锁最多等待的时间、获取锁后自动释放的时间、时间单元。

@Scheduled(cron = "0 */1 * * * ?")
public void closeOrderTaskV4() {
    RLock lock = redissonManager.getRedisson().getLock(Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK);
    boolean locked = false;
    try {
        if(locked = lock.tryLock(0, 5, TimeUnit.SECONDS)) {
            log.info("Redisson 获取到分布式锁：{}, ThreadName:{}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, Thread.currentThread().getName());
            int hour = Integer.parseInt(PropertiesUtil.getProperty("close.order.task.time.hour", "2"));
            iOrderService.closeOrder(hour);
        } else {
            log.info("Redisson 没有获取到分布式锁：{}, ThreadName:{}", Const.REDIS_LOCK.CLOSE_ORDER_TASK_LOCK, Thread.currentThread().getName());

        }
    } catch (InterruptedException e) {
        log.error("Redisson 获取分布式锁异常", e);
    } finally {
        if (!locked) {
            return;
        }
        lock.unlock();
        log.info("Redisson 释放分布式锁");
    }
}
复制代码

这里 tryLock 方法在获取锁之后，如果后续的执行业务时间小于 1 秒，而另外的 tomcat 在等待 1 秒后，又能重新获取锁，就会出现两个进程都获得锁的情况。

所以，应该将 waitTime 设置为 0 （ waitTime 时间小于业务执行时间）。