订单30分钟未支付自动取消怎么实现？

本文已经收录到Github库房，该库房包括计算机根底、Java核心知识点、多线程、JVM、常见框架、分布式、微服务、设计形式、架构等核心知识点，欢迎star~

地址：github.com/Tyson0314/J…

目录

• 了解需求
• 计划 1：数据库轮询
• 计划 2：JDK 的推迟行列
• 计划 3：时刻轮算法
• 计划 4：redis 缓存
• 计划 5：运用音讯行列

了解需求

在开发中，往往会遇到一些关于延时使命的需求。

例如

• 生成订单 30 分钟未付出，则自动撤销
• 生成订单 60 秒后,给用户发短信

对上述的使命，咱们给一个专业的姓名来形容，那便是延时使命。那么这儿就会产生一个问题，这个延时使命和守时使命的差异究竟在哪里呢？一共有如下几点差异

守时使命有明确的触发时刻，延时使命没有

守时使命有履行周期，而延时使命在某事情触发后一段时刻内履行，没有履行周期

守时使命一般履行的是批处理操作是多个使命，而延时使命一般是单个使命

下面，咱们以判别订单是否超时为例，进行计划剖析

计划 1：数据库轮询

思路

该计划通常是在小型项目中运用，即经过一个线程守时的去扫描数据库，经过订单时刻来判别是否有超时的订单，然后进行 update 或 delete 等操作

完成

能够用 quartz 来完成的，简单介绍一下

maven 项目引入一个依靠如下所示

<dependency>
   <groupId>org.quartz-scheduler</groupId>
   <artifactId>quartz</artifactId>
   <version>2.2.2</version>
</dependency>

调用 Demo 类 MyJob 如下所示

package com.rjzheng.delay1;
​
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
​
public class MyJob implements Job {
​
   public void execute(JobExecutionContext context) throws JobExecutionException {
     System.out.println("要去数据库扫描啦。。。");
   }
​
   public static void main(String[] args) throws Exception {
     // 创立使命
     JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
         .withIdentity("job1", "group1").build();
     // 创立触发器 每3秒钟履行一次
     Trigger trigger = TriggerBuilder
         .newTrigger()
         .withIdentity("trigger1", "group3")
         .withSchedule(
             SimpleScheduleBuilder
                 .simpleSchedule()
                 .withIntervalInSeconds(3).
                 repeatForever())
         .build();
     Scheduler scheduler = new StdSchedulerFactory().getScheduler();
     // 将使命及其触发器放入调度器
     scheduler.scheduleJob(jobDetail, trigger);
     // 调度器开始调度使命
     scheduler.start();
   }
​
}

运转代码，可发现每隔 3 秒，输出如下

要去数据库扫描啦。。。

长处

简单易行，支持集群操作

缺陷

• 对服务器内存消耗大
• 存在推迟，比方你每隔 3 分钟扫描一次，那最坏的推迟时刻便是 3 分钟
• 假定你的订单有几千万条，每隔几分钟这样扫描一次，数据库损耗极大

计划 2：JDK 的推迟行列

思路

该计划是运用 JDK 自带的 DelayQueue 来完成，这是一个无界堵塞行列，该行列只要在推迟期满的时候才能从中获取元素，放入 DelayQueue 中的对象，是有必要完成 Delayed 接口的。

DelayedQueue 完成工作流程如下图所示

其中 Poll():获取并移除行列的超时元素，没有则回来空

take():获取并移除行列的超时元素，假如没有则 wait 当时线程，直到有元素满意超时条件，回来结果。

完成

定义一个类 OrderDelay 完成 Delayed，代码如下

package com.rjzheng.delay2;
​
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
​
public class OrderDelay implements Delayed {
​
   private String orderId;
​
   private long timeout;
​
   OrderDelay(String orderId, long timeout) {
     this.orderId = orderId;
     this.timeout = timeout + System.nanoTime();
   }
​
   public int compareTo(Delayed other) {
     if (other == this) {
       return 0;
     }
     OrderDelay t = (OrderDelay) other;
     long d = (getDelay(TimeUnit.NANOSECONDS) - t.getDelay(TimeUnit.NANOSECONDS));
     return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
   }
​
   // 回来间隔你自定义的超时时刻还有多少
   public long getDelay(TimeUnit unit) {
     return unit.convert(timeout - System.nanoTime(), TimeUnit.NANOSECONDS);
   }
​
   void print() {
     System.out.println(orderId + "编号的订单要删去啦。。。。");
   }
​
}

运转的测验 Demo 为，咱们设定推迟时刻为 3 秒

package com.rjzheng.delay2;
​
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.TimeUnit;
​
public class DelayQueueDemo {
​
   public static void main(String[] args) {
     List<String> list = new ArrayList<String>();
     list.add("00000001");
     list.add("00000002");
     list.add("00000003");
     list.add("00000004");
     list.add("00000005");
​
     DelayQueue<OrderDelay> queue = newDelayQueue < OrderDelay > ();
     long start = System.currentTimeMillis();
     for (int i = 0; i < 5; i++) {
       //推迟三秒取出
       queue.put(new OrderDelay(list.get(i), TimeUnit.NANOSECONDS.convert(3, TimeUnit.SECONDS)));
       try {
         queue.take().print();
         System.out.println("After " + (System.currentTimeMillis() - start) + " MilliSeconds");
       } catch (InterruptedException e) {
         e.printStackTrace();
       }
     }
   }
​
}

输出如下

00000001编号的订单要删去啦。。。。
After 3003 MilliSeconds
00000002编号的订单要删去啦。。。。
After 6006 MilliSeconds
00000003编号的订单要删去啦。。。。
After 9006 MilliSeconds
00000004编号的订单要删去啦。。。。
After 12008 MilliSeconds
00000005编号的订单要删去啦。。。。
After 15009 MilliSeconds

能够看到都是推迟 3 秒，订单被删去

长处

效率高,使命触发时刻推迟低。

缺陷

• 服务器重启后，数据悉数消失，怕宕机
• 集群扩展适当麻烦
• 因为内存条件限制的原因，比方下单未付款的订单数太多，那么很简单就呈现 OOM 反常
• 代码复杂度较高

计划 3：时刻轮算法

思路

先上一张时刻轮的图(这图处处都是啦)

时刻轮算法能够类比于时钟，如上图箭头（指针）按某一个方向按固定频率轮动，每一次跳动称为一个 tick。这样能够看出守时轮由个 3 个重要的属性参数，ticksPerWheel（一轮的 tick 数），tickDuration（一个 tick 的持续时刻）以及 timeUnit（时刻单位），例如当 ticksPerWheel=60，tickDuration=1，timeUnit=秒，这就和现实中的始终的秒针走动完全相似了。

假如当时指针指在 1 上面，我有一个使命需求 4 秒以后履行，那么这个履行的线程回调或者音讯将会被放在 5 上。那假如需求在 20 秒之后履行怎么办，因为这个环形结构槽数只到 8，假如要 20 秒，指针需求多转 2 圈。方位是在 2 圈之后的 5 上面（20 % 8 + 1）

完成

咱们用 Netty 的 HashedWheelTimer 来完成

给 Pom 加上下面的依靠

<dependency>
   <groupId>io.netty</groupId>
   <artifactId>netty-all</artifactId>
   <version>4.1.24.Final</version>
</dependency>

测验代码 HashedWheelTimerTest 如下所示

package com.rjzheng.delay3;
​
import io.netty.util.HashedWheelTimer;
import io.netty.util.Timeout;
import io.netty.util.Timer;
import io.netty.util.TimerTask;
​
import java.util.concurrent.TimeUnit;
​
public class HashedWheelTimerTest {
​
   static class MyTimerTask implements TimerTask {
​
     boolean flag;
​
     public MyTimerTask(boolean flag) {
       this.flag = flag;
     }
​
     public void run(Timeout timeout) throws Exception {
       System.out.println("要去数据库删去订单了。。。。");
       this.flag = false;
     }
   }
​
   public static void main(String[] argv) {
     MyTimerTask timerTask = new MyTimerTask(true);
     Timer timer = new HashedWheelTimer();
     timer.newTimeout(timerTask, 5, TimeUnit.SECONDS);
     int i = 1;
     while (timerTask.flag) {
       try {
         Thread.sleep(1000);
       } catch (InterruptedException e) {
         e.printStackTrace();
       }
       System.out.println(i + "秒过去了");
       i++;
     }
   }
​
}

输出如下

1秒过去了
2秒过去了
3秒过去了
4秒过去了
5秒过去了
要去数据库删去订单了。。。。
6秒过去了

长处

效率高,使命触发时刻推迟时刻比 delayQueue 低，代码复杂度比 delayQueue 低。

缺陷

• 服务器重启后，数据悉数消失，怕宕机
• 集群扩展适当麻烦
• 因为内存条件限制的原因，比方下单未付款的订单数太多，那么很简单就呈现 OOM 反常

计划 4：redis 缓存

思路一

运用 redis 的 zset,zset 是一个有序调集，每一个元素(member)都相关了一个 score,经过 score 排序来取调集中的值

增加元素:ZADD key score member [score member …]

按顺序查询元素:ZRANGE key start stop [WITHSCORES]

查询元素 score:ZSCORE key member

移除元素:ZREM key member [member …]

测验如下

增加单个元素
redis> ZADD page_rank 10 google.com
(integer) 1
​
增加多个元素
redis> ZADD page_rank 9 baidu.com 8 bing.com
(integer) 2
​
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"
5) "google.com"
6) "10"
​
查询元素的score值
redis> ZSCORE page_rank bing.com
"8"
​
移除单个元素
redis> ZREM page_rank google.com
(integer) 1
​
redis> ZRANGE page_rank 0 -1 WITHSCORES
1) "bing.com"
2) "8"
3) "baidu.com"
4) "9"

那么怎么完成呢？咱们将订单超时时刻戳与订单号分别设置为 score 和 member,体系扫描第一个元素判别是否超时，详细如下图所示

完成一

package com.rjzheng.delay4;
​
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Tuple;
​
import java.util.Calendar;
import java.util.Set;
​
public class AppTest {
​
   private static final String ADDR = "127.0.0.1";
​
   private static final int PORT = 6379;
​
   private static JedisPool jedisPool = new JedisPool(ADDR, PORT);
​
   public static Jedis getJedis() {
     return jedisPool.getResource();
   }
​
   //生产者,生成5个订单放进去
   public void productionDelayMessage() {
     for (int i = 0; i < 5; i++) {
       //推迟3秒
       Calendar cal1 = Calendar.getInstance();
       cal1.add(Calendar.SECOND, 3);
       int second3later = (int) (cal1.getTimeInMillis() / 1000);
       AppTest.getJedis().zadd("OrderId", second3later, "OID0000001" + i);
       System.out.println(System.currentTimeMillis() + "ms:redis生成了一个订单使命：订单ID为" + "OID0000001" + i);
     }
   }
​
   //顾客，取订单
​
   public void consumerDelayMessage() {
     Jedis jedis = AppTest.getJedis();
     while (true) {
       Set<Tuple> items = jedis.zrangeWithScores("OrderId", 0, 1);
       if (items == null || items.isEmpty()) {
         System.out.println("当时没有等候的使命");
         try {
           Thread.sleep(500);
         } catch (InterruptedException e) {
           e.printStackTrace();
         }
         continue;
       }
       int score = (int) ((Tuple) items.toArray()[0]).getScore();
       Calendar cal = Calendar.getInstance();
       int nowSecond = (int) (cal.getTimeInMillis() / 1000);
       if (nowSecond >= score) {
         String orderId = ((Tuple) items.toArray()[0]).getElement();
         jedis.zrem("OrderId", orderId);
         System.out.println(System.currentTimeMillis() + "ms:redis消费了一个使命：消费的订单OrderId为" + orderId);
       }
     }
   }
​
   public static void main(String[] args) {
     AppTest appTest = new AppTest();
     appTest.productionDelayMessage();
     appTest.consumerDelayMessage();
   }
​
}

此时对应输出如下

能够看到，简直都是 3 秒之后，消费订单。

然而，这一版存在一个致命的硬伤，在高并发条件下，多顾客会取到同一个订单号，咱们上测验代码 ThreadTest

package com.rjzheng.delay4;
​
import java.util.concurrent.CountDownLatch;
​
public class ThreadTest {
​
   private static final int threadNum = 10;
   private static CountDownLatch cdl = newCountDownLatch(threadNum);
​
   static class DelayMessage implements Runnable {
     public void run() {
       try {
         cdl.await();
       } catch (InterruptedException e) {
         e.printStackTrace();
       }
       AppTest appTest = new AppTest();
       appTest.consumerDelayMessage();
     }
   }
​
   public static void main(String[] args) {
     AppTest appTest = new AppTest();
     appTest.productionDelayMessage();
     for (int i = 0; i < threadNum; i++) {
       new Thread(new DelayMessage()).start();
       cdl.countDown();
     }
   }
​
}

输出如下所示

显着，呈现了多个线程消费同一个资源的状况。

解决计划

(1)用分布式锁，但是用分布式锁，功用下降了，该计划不细说。

(2)对 ZREM 的回来值进行判别，只要大于 0 的时候，才消费数据，于是将 consumerDelayMessage()办法里的

if(nowSecond >= score){
   String orderId = ((Tuple)items.toArray()[0]).getElement();
   jedis.zrem("OrderId", orderId);
   System.out.println(System.currentTimeMillis()+"ms:redis消费了一个使命：消费的订单OrderId为"+orderId);
}

修改为

if (nowSecond >= score) {
   String orderId = ((Tuple) items.toArray()[0]).getElement();
   Long num = jedis.zrem("OrderId", orderId);
   if (num != null && num > 0) {
     System.out.println(System.currentTimeMillis() + "ms:redis消费了一个使命：消费的订单OrderId为" + orderId);
   }
}

在这种修改后，从头运转 ThreadTest 类，发现输出正常了

思路二

该计划运用 redis 的 Keyspace Notifications，中文翻译便是键空间机制，便是运用该机制能够在 key 失效之后，供给一个回调，实际上是 redis 会给客户端发送一个音讯。是需求 redis 版本 2.8 以上。

完成二

在 redis.conf 中，加入一条装备

notify-keyspace-events Ex

运转代码如下

package com.rjzheng.delay5;
​
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPubSub;
​
public class RedisTest {
​
   private static final String ADDR = "127.0.0.1";
   private static final int PORT = 6379;
   private static JedisPool jedis = new JedisPool(ADDR, PORT);
   private static RedisSub sub = new RedisSub();
​
   public static void init() {
     new Thread(new Runnable() {
       public void run() {
         jedis.getResource().subscribe(sub, "__keyevent@0__:expired");
       }
     }).start();
   }
​
   public static void main(String[] args) throws InterruptedException {
     init();
     for (int i = 0; i < 10; i++) {
       String orderId = "OID000000" + i;
       jedis.getResource().setex(orderId, 3, orderId);
       System.out.println(System.currentTimeMillis() + "ms:" + orderId + "订单生成");
     }
   }
​
   static class RedisSub extends JedisPubSub {
     @Override
     public void onMessage(String channel, String message) {
       System.out.println(System.currentTimeMillis() + "ms:" + message + "订单撤销");
​
     }
   }
}

输出如下

能够显着看到 3 秒往后，订单撤销了

ps:redis 的 pub/sub 机制存在一个硬伤，官网内容如下

原:Because Redis Pub/Sub is fire and forget currently there is no way to use this feature if your application demands reliable notification of events, that is, if your Pub/Sub client disconnects, and reconnects later, all the events delivered during the time the client was disconnected are lost.

翻: Redis 的发布/订阅目前是即发即弃(fire and forget)形式的，因而无法完成事情的可靠告诉。也便是说，假如发布/订阅的客户端断链之后又重连，则在客户端断链期间的所有事情都丢掉了。因而，计划二不是太引荐。当然，假如你对可靠性要求不高，能够运用。

长处

(1) 因为运用 Redis 作为音讯通道，音讯都存储在 Redis 中。假如发送程序或者使命处理程序挂了，重启之后，还有从头处理数据的可能性。

(2) 做集群扩展适当便利

(3) 时刻准确度高

缺陷

需求额外进行 redis 维护

计划 5：运用音讯行列

思路

咱们能够选用 rabbitMQ 的延时行列。RabbitMQ 具有以下两个特性，能够完成推迟行列

RabbitMQ 能够针对 Queue 和 Message 设置 x-message-tt，来操控音讯的生存时刻，假如超时，则音讯变为 dead letter

lRabbitMQ 的 Queue 能够装备 x-dead-letter-exchange 和 x-dead-letter-routing-key（可选）两个参数，用来操控行列内呈现了 deadletter，则依照这两个参数从头路由。结合以上两个特性，就能够模拟出推迟音讯的功用,详细的，我改天再写一篇文章，这儿再讲下去，篇幅太长。

长处

高效,能够运用 rabbitmq 的分布式特性容易的进行横向扩展,音讯支持耐久化增加了可靠性。

缺陷

本身的易用度要依靠于 rabbitMq 的运维.因为要引证 rabbitMq,所以复杂度和本钱变高。