程序员Wiki

当使用 12306 抢票成功后，就会进入付款界面，这个时候就会出现一个订单倒计时，下面我们就对付款倒计时的功能实现，进行深入学习和介绍，界面展示如下：

缓存

如何实现付款及时呢，首先用户下单后，存储用户的下单时间。下面介绍四种系统自动取消订单的方案：

# 一、DelayQueue 延时无界阻塞队列

我们的第一反应是用 数据库轮序+任务调度 来实现此功能。但这种高效率的延迟任务用任务调度（定时器）实现就得不偿失。而且对系统也是一种压力且数据库消耗极大。因此我们使用 Java 延迟队列 DelayQueue 来实现，DelayQueue 是一个无界的延时阻塞队列（BlockingQueue），用于存放实现了 Delayed 接口的对象，队列中的对象只能在其到期时才能从队列中取走。这种队列是有序的，既队头对象的延迟到期时间最长。

//加入delayQueue的对象，必须实现Delayed接口，同时实现如下：compareTo和GetDelay方法
static class DelayItem implements Delayed{
     //过期时间(单位：分钟)
     private long expTime;
     private String orderCode;

     public DelayItem(String orderCode,long expTime,Date createTime) {
          super();
          this.orderCode=orderCode;
          this.expTime=TimeUnit.MILLISECONDS.convert(expTime, TimeUnit.MINUTES)+createTime.getTime();
     }
     /**
     * 用于延迟队列内部比较排序，当前时间的延迟时间  -  比较对象的延迟时间
     */
     @Override
     public int compareTo(Delayed o) {
          return Long.valueOf(this.expTime).compareTo(Long.valueOf(((DelayItem)o).expTime));
     }

     /**
     * 获得延迟时间，过期时间-当前时间（单位ms）
     */
     @Override
     public long getDelay(TimeUnit unit) {
          return this.expTime-System.currentTimeMillis();
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

将未付款的订单都 add 到延迟队列中，并通过线程池启动多个线程不断获取延迟队列的内容，获取到后进行状态的修改，进行业务逻辑处理。具体代码如下：

public class DelayQueueTest implements Runnable{
    //创建一个延迟队列
    private    DelayQueue<Delayed> item = new DelayQueue<>();

    @Override
    public void run() {
         while(true) {
          try {
            //只有当到期了才会获取到此对象
            DelayItem delayed = (DelayItem) item.take();
                //获取到之后修改状态
           } catch (InterruptedException e) {
                    e.printStackTrace();
           }
         }
    }

        //添加数据调用的方法
    public void orderTimer(DelayItem delayItem) {
        //向队列汇总添加数据
        item.add(delayItem);
    }

    public static void main(String[] args) {
          //创建一个线程池
          ExecutorService executor = Executors.newCachedThreadPool();
          //多线程执行程序
          executor.execute(new DelayQueueTest());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

这种方案的缺点：
【1】代码复杂度较高，大量消息堆积，性能不能保证，且很容易触发OOM。
【2】需要考虑分布式的实现、存在单点故障。

# 二、环形队列

58同城架构沈剑提供一种基于时间轮的环形队列算法，在他的分享中，一个高效延时消息，包含两个重要的数据结构：
【1】环形队列，例如可以创建一个包含3600个 slot 的环形队列（本质是个数组）
【2】任务集合，环上每一个 slot 是一个 Set<Task>

同时，启动一个 timer ，这个 timer 每隔一秒，在上述环形队列中移动一格，有一个 Current Index 指针来标识正在检测的 slot。环形队列分为 3600 个长度，每秒移动一格，移动 3600 秒正好一个小时。比如一个任务需要在60秒后执行，那这个任务应该放在那个槽位的集合里呢？假设当前指针移动到 slot 的位置为2，那么60秒后的槽位就是62，所以数据应该放在索引为 62 的那个槽位圈数为0。如果这个任务要70分钟，70*60+2=4202，4202-3600=602，减了一次3600，所以应该放在第二圈的602槽位，既放在队列索引为602槽位的集合，且圈数为1，代表运行一圈后才执行这个任务。

这种方案效率高，任务触发时间延迟时间比 delayQueue 低，代码复杂度 delayQueue 低，但没有公开源码，不过通过次思路可以实现次组件，当然缺点和 delayQueue 相同。

缓存

# 三、使用 Redis 实现

通过 Redis ZSet 类型及操作命令实现一个延迟队列，用时间戳（当前时间+延迟的分钟数）作为元素的 score 存入ZSet。只需获取 zset中的第一条记录，即最早时间下单数据，如果该记录未超时支付，剩下的订单必然未超时。

public class DelayQueueComponent {
    private final static String delayQueueKey = "delay:queue";

    @Autowired
    private RedisService redisService;

    // 将延迟对象推送至队列中
    public void add(Object obj, long seconds) {
        this.redisService.zadd(delayQueueKey, obj, getDelayTimeMills(seconds));
    }

    public void startMonitor() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                monitorQueue();
            }
        };
        System.out.println("start monitor delay queue.");
        new Thread(runnable).start();
        System.out.println("finish start monitor delay queue.");
    }

    private void monitorQueue() {
        while(true) {
            if(lock()) {
                //从延迟队列中拿一个最旧的
                TypedTuple<Object> tuple = this.redisService.zrangeFirst(delayQueueKey);
                // isCanPush 判断是否延迟
                if(isCanPush(tuple)) {
                    //删除掉处理的延迟消息
                    this.redisService.zremFirst(delayQueueKey);
                    //释放锁
                    releaseLock();
                }else {
                    releaseLock();
                }
            }
            sleep();
        }
    }

     // 是否可推送
    private boolean isCanPush(TypedTuple<Object> tuple) {
        if(tuple == null) {
            return false;
        }
        long currentTimeMills = System.currentTimeMillis();
        //当前时间小于延迟时间时,获取对象进行业务逻辑处理
        if(currentTimeMills >= tuple.getScore()) {
            return true;
        }
        return false;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

这种方案的缺点：
【1】消息处理失败，不能恢复处理。
【2】数据量大时，zset 性能有问题，多定义几个 zset，增加了内存和定时器去读的复杂度。

# 四、RabbitMQ 实现

利用 RabbitMQ做延时队列是比较常见的一种方式，而实际上 RabbitMQ自身并没有直接支持提供延迟队列功能，而是通过 RabbitMQ 消息队列的 TTL和 DLX这两个属性间接实现的。

TIP

Time To Live（TTL）：消息的存活时间，RabbitMQ可以通过 x-message-tt参数来设置指定Queue（队列）和 Message（消息）上消息的存活时间，它的值是一个非负整数，单位为微秒。

RabbitMQ 可以从两种维度设置消息过期时间，分别是队列和消息本身：
【1】设置队列过期时间，那么队列中所有消息都具有相同的过期时间。
【2】设置消息过期时间，对队列中的某一条消息设置过期时间，每条消息TTL都可以不同。
如果同时设置队列和队列中消息的TTL，则TTL值以两者中较小的值为准。而队列中的消息存在队列中的时间，一旦超过TTL过期时间则成为Dead Letter（死信）。

队列出现 Dead Letter的情况有：
【1】消息或者队列的TTL过期；
【2】队列达到最大长度；
【3】消息被消费端拒绝（basic.reject or basic.nack）；

应用场景：一般应用在当正常业务处理时出现异常时，将消息拒绝则会进入到死信队列中，有助于统计异常数据并做后续处理；重试队列在重试16次（默认次数）将消息放入死信队列。利用 RabbitMQ 的死信队列（Dead-Letter-Exchage）机制实现，在 queueDeclare 方法中加入 “x-dead-letter-exchage”实现：

TIP

RabbitMQ的 Queue可以配置 x-dead-letter-exchange 和 x-dead-letter-routing-key（可选）两个参数，如果队列内出现了dead letter，则按照这两个参数重新路由转发到指定的队列。 x-dead-letter-exchage：过期消息路由转发（转发器类型） x-dead-letter-routing-key：当消息达到过期时间由该 exchange 安装配置的 x-dead-letter-routing-key 转发到指定队列，最后被消费者消费

下边结合一张图看看如何实现超30分钟未支付关单功能，我们将订单消息A0001发送到延迟队列order.delay.queue，并设置x-message-tt消息存活时间为30分钟，当到达30分钟后订单消息A0001成为了Dead Letter（死信），延迟队列检测到有死信，通过配置x-dead-letter-exchange，将死信重新转发到能正常消费的队列，直接监听队列处理关闭订单逻辑即可。

缓存

我们需要两个队列，一个用来做主队列，真正的投递消息；另一个用来延迟处理消息。

channel.queueDeclare("MAIN_QUEUE",true,false,false,null);
channel.queueBind("MAIN_QUEUE","amq.direct","MAIN_QUEUE");

HashMap<String,Object> arguments = new HashMap<String,Object>();
arguments.put("x-dead-letter-exchange","amq.direct");
arguments.put("x-dead-letter-routing-key","MAIN_QUEUE");

channel.queueDeclare("DELAY_QUEUE",true,false,false,arguments);
1
2
3
4
5
6
7
8

放入延迟消息（DeliveryMode 等于 2 说明这个消息是 persistent 的）：

AMQP.BasicProperties.Builder builder = new AMQP.BasicProperties.Builder();
AMQP.BasicProperties properties = builder.expiration(
                    String.valueOf(task.getDelayMillis())).deliveryMode(2).build();
channel.basicPublish("","DELAY_QUEUE",properties,SerializationUtils.serialize(task));
1
2
3
4

这种方案的缺点：
【1】笔者之前做 MQ 性能测试时，在公司的服务器上单机 TPS 接近 3W，如果是中小型企业级应用基本满足。但如果大量的消息积压得不到投递，性能仍然是个问题。
【2】依赖于 RabbitMQ 的运维，复杂度和成本提高。 ​

(adsbygoogle = window.adsbygoogle || []).push({});

← 面试经验之谈 →