经典面试题：订单超时问题（1）

经典面试题：订单超时问题

问题引出

外卖、京东淘宝拼多多抖音商城下单、机票火车票门票、酒店饭店预定、上门服务、限时抽奖、限时优惠券……

候选解决方案

• 方案1：定时任务Scheduled
• 方案2：延时队列DelayQueue
• 方案3：时间轮算法HashedWheelTimer
• 方案4：Redis事件通知机制
• 方案5：MQ消息队列

方案1：定时任务Scheduled

(好用又方便，首选SpringBoot)

方案思路

1. 使用数据库或缓存来保存订单数据；
2. Spring框架内置的Scheduled组件来做定时器；
3. 指定间隔时间获取未付款订单，逐条检查是否过期。

(示例代码仅展示核心的“超时”逻辑)

依赖、配置和核心代码

pom.xml

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.3</version>
    </parent>
    
    <dependencies>
    	<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- hutool工具包，非必要 -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.3</version>
        </dependency>
        
        <!-- lombok，非必要 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

没有任何特殊依赖，就是一个普通SpringBoot项目

application.yml

server:
  port: 18080

spring:
  application:
    name: springboot-commontest

也没有任何特殊配置

import cn.hutool.core.thread.ThreadUtil;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

@EnableScheduling   // 必须同时启用@EnableScheduling，否则@Scheduled注解的定时任务不会生效
@EnableAsync		// 异步处理，可避免任务不准时
public class SpringScheduledTest {

    /**

     */
    @Scheduled(fixedDelay = 3000)   // 上次任务执行完成后，再延时3秒后执行
    public void test1() {
        System.out.println("------------------------ 模拟去拿未付款订单 ---------------------------");
        System.out.println("---> 拿到未付款订单，逐条订单检查，如果超时则关闭订单，并释放库存 <---");
        ThreadUtil.safeSleep(1500);
        System.out.println("---------------------------- 结束模拟 --------------------------------");
    }

效果

显而易见

优缺点

 *      优点:
 *          简单易行，支持集群操作
 *      缺点:
 *          对服务器内存消耗大
 *          存在延迟，比如你每隔3分钟扫描一次，那最坏的延迟时间就是3分钟
 *          假设你的订单有几千万条，每隔几分钟这样扫描一次，数据库损耗极大

---

方案2：延时队列DelayQueue

方案思路

1. 使用数据库或缓存来保存完整订单数据；
2. 通过实现J.U.C自带的Delayed接口来做延时订单对象，一条订单对应一个对象实例，用于解决方案1需要扫描db所有未付款订单的问题；
3. 把订单放入到延时队列DelayQueue中；
4. 启用一个线程作为消费者循环处理DelayQueue中过期的订单数据。

(示例代码仅展示核心的“超时”逻辑)

依赖、配置和核心代码

pom.xml

同上，略...

application.yml

同上，略...

1. 编写延时订单对象：
   OrderDelayTask.java

import lombok.Data;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

@Data
public class OrderDelayTask implements Delayed {

    private Long orderId;

    private Long delayTime;

    public OrderDelayTask(long orderId, long delayTime) {
        this.orderId = orderId;
        this.delayTime = System.currentTimeMillis() + delayTime;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return delayTime - System.currentTimeMillis();
    }

    @Override
    public int compareTo(Delayed o) {
        return Long.compare(this.delayTime, ((OrderDelayTask) o).delayTime);
    }
}

2. 配置并注入延时队列
   DelayQueueConfig.java

import java.util.concurrent.DelayQueue;

@Configuration
public class DelayQueueConfig {

    @Bean
    public DelayQueue<OrderDelayTask> delayQueue() {
        return new DelayQueue<>();
    }
}

3. 模拟后端接口监听订单提交，把未付款的订单放入到延时队列中：
   OrderNotPaidController.java

	@Resource
    private DelayQueue<OrderDelayTask> orderDelayQueue;

    @PostMapping("/order")
    public String addOrderNotPaid(@RequestBody OrderDelayTask order) {
        System.out.println("Add order to delay queue...");
        // 模拟随机ID
        order.setOrderId(RandomUtil.randomLong());
        orderDelayQueue.put(order); // 模拟30秒后订单超时

        String result = "订单【" + order.getOrderId() + "】将在30秒后超时，请尽快支付！当前时间：" + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"));
        System.out.println(result);
        return result;
    }

4. 启用一个线程作为消费者循环处理DelayQueue中过期的订单数据
   ExpiredOrderConsumer.java

import org.springframework.boot.CommandLineRunner;
import javax.annotation.Resource;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.DelayQueue;

public class ExpiredOrderConsumer implements CommandLineRunner {

    @Resource
    private DelayQueue<OrderDelayTask> orderDelayQueue;

    @Override
    public void run(String... args) {
        new Thread(() -> {
            try {
                while(true) {
                    System.out.println("开始等待处理订单超时...");
                    OrderDelayTask task = orderDelayQueue.take();
                    // 当队列为null的时候，poll()方法会直接返回null, 不会抛出异常，但是take()方法会一直等待，当收到中断请求的时候就会抛出InterruptedException异常
                    System.out.println("订单【" + task.getOrderId() + "】超时，执行相应操作...\t当前时间：" + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")) + "\t\t当前线程：" + Thread.currentThread().getName());
                    // 执行业务
                }
            } catch (InterruptedException e) {
            	// 异常不能往外抛，那就处理该异常或者设置中断标志位
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

效果

调用/order接口，给定30秒超时：

curl -X POST --location "http://localhost:18080/order" \
    -H "Content-Type: application/json" \
    -d "{
          \"orderId\": 0,
          \"delayTime\": 30000
        }"

优缺点

 *      优点:
 *          效率高,任务触发时间延迟低。
 *      缺点:
 *          服务器重启后，数据全部消失，怕宕机
 *          集群扩展相当麻烦
 *          因为内存条件限制的原因，比如下单未付款的订单数太多，那么很容易就出现OOM异常
 *          代码复杂度较高

---

方案3：时间轮算法HashedWheelTimer

方案思路

1. 与方案2相似，只是用Netty的组件替代了JUC的组件，降低了代码复杂度；
2. 通过实现Netty自带的TimerTask接口来做定时任务对象，一条订单对应一个对象实例；
3. 把订单放入到时间轮HashedWheelTimer中，等待超时后自动触发即可。

(示例代码仅展示核心的“超时”逻辑)

依赖、配置和核心代码

pom.xml

		<!--使用其内部的“时间轮定时器”-->
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-common</artifactId>
        </dependency>

application.yml

同上，略...

1. 编写订单定时任务对象：
   OrderTimerTask.java

import io.netty.util.Timeout;
import io.netty.util.TimerTask;

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class OrderTimerTask implements TimerTask {

    private Long orderId;

    public OrderTimerTask(Long orderId) {
        this.orderId = orderId;
    }
    @Override
    public void run(Timeout timeout) {
        System.out.println("订单【" + this.orderId + "】超时，执行相应操作...\t当前时间：" + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")) + "\t\t当前线程：" + Thread.currentThread().getName());
    }

    public Long getOrderId() {
        return this.orderId;
    }
}

2. 配置并注入时间轮定时器组件
   WheelTimerConfig.java

import io.netty.util.HashedWheelTimer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.concurrent.TimeUnit;

@Configuration
public class WheelTimerConfig {

    @Bean
    public HashedWheelTimer hashedWheelTimer() {
        return new HashedWheelTimer(1L, TimeUnit.SECONDS, 30);
    }
}

3. 模拟后端接口监听订单提交，把未付款的订单放入到时间轮定时器中：
   OrderNotPaidController.java

	private final HashedWheelTimer wheelTimer;

    public OrderNotPaidController(@Autowired HashedWheelTimer wheelTimer){
        this.wheelTimer = wheelTimer;
        System.out.println("开始等待处理订单超时...");
        //wheelTimer.start();
    }

    @PostMapping("/order")
    public String addOrderNotPaid(@RequestBody OrderEntity order) {
        System.out.println("用户提交订单，未付款订单需在xx分钟内完成支付，否则自动取消订单。");
        OrderTimerTask timerTask = new OrderTimerTask(RandomUtil.randomLong(1000000L));
        wheelTimer.newTimeout(timerTask, 30L, TimeUnit.SECONDS);

        String result = "订单【" + timerTask.getOrderId() + "】将在30秒后超时，请尽快支付！当前时间：" + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"));
        System.out.println(result);
        return result;
    }

效果

同上，略……

优缺点

 *      优点:
 *          效率高，任务触发时间延迟时间比delayQueue低，代码复杂度比delayQueue低。
 *      缺点:
 *          服务器重启后，数据全部消失，怕宕机
 *          集群扩展相当麻烦
 *          因为内存条件限制的原因，比如下单未付款的订单数太多，那么很容易就出现OOM异常

---

下篇继续…