订单30分钟未支付则自动取消的几种方法

(1)数据库轮询

思路

该方案通常是在小型项目中使用，即通过一个线程定时的去扫描数据库，通过订单时间来判断是否有超时的订单，然后进行update或delete等操作

优缺点

优点:简单易行，支持集群操作

缺点:

• (1)对服务器内存消耗大
• (2)存在延迟，比如你每隔3分钟扫描一次，那最坏的延迟时间就是3分钟
• (3)假设你的订单有几千万条，每隔几分钟这样扫描一次，数据库损耗极大

(2)redis缓存

思路一

利用redis的zset,zset是一个有序集合，每一个元素(member)都关联了一个score,通过score排序来取集合中的值

zset常用命令

• 添加元素:ZADD key score member [[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 java.util.Calendar;
import java.util.Set;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.Tuple;

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) {
     // TODO Auto-generated catch block
     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();
 }
 
}

此时对应输出如下

1525086085261ms:redis生成了一个订单任务：订单ID为OID00000010
1525086085263ms:redis生成了一个订单任务：订单ID为OID00000011
1525086085266ms:redis生成了一个订单任务：订单ID为OID00000012
1525086085268ms:redis生成了一个订单任务：订单ID为OID00000013
1525086085270ms:redis生成了一个订单任务：订单ID为OID00000014
1525086088000ms:redis消费了一个任务：消费的订单OrderId为OID00000010
1525086088001ms:redis消费了一个任务：消费的订单OrderId为OID00000011
1525086088002ms:redis消费了一个任务：消费的订单OrderId为OID00000012
1525086088003ms:redis消费了一个任务：消费的订单OrderId为OID00000013
1525086088004ms:redis消费了一个任务：消费的订单OrderId为OID00000014
当前没有等待的任务
当前没有等待的任务
当前没有等待的任务

可以看到，几乎都是3秒之后，消费订单。

然而，这一版存在一个致命的硬伤，在高并发条件下，多消费者会取到同一个订单号，我们上测试代码ThreadTest

package com.rjzheng.delay4;

import java.util.concurrent.CountDownLatch;

public class ThreadTest {
 private static final int threadNum = 10;
 private static CountDownLatch cdl = new CountDownLatch(threadNum);
 static class DelayMessage implements Runnable{
  public void run() {
   try {
    cdl.await();
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    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();
  }
 }
}

输出如下所示

1525087157727ms:redis生成了一个订单任务：订单ID为OID00000010
1525087157734ms:redis生成了一个订单任务：订单ID为OID00000011
1525087157738ms:redis生成了一个订单任务：订单ID为OID00000012
1525087157747ms:redis生成了一个订单任务：订单ID为OID00000013
1525087157753ms:redis生成了一个订单任务：订单ID为OID00000014
1525087160009ms:redis消费了一个任务：消费的订单OrderId为OID00000010
1525087160011ms:redis消费了一个任务：消费的订单OrderId为OID00000010
1525087160012ms:redis消费了一个任务：消费的订单OrderId为OID00000010
1525087160022ms:redis消费了一个任务：消费的订单OrderId为OID00000011
1525087160023ms:redis消费了一个任务：消费的订单OrderId为OID00000011
1525087160029ms:redis消费了一个任务：消费的订单OrderId为OID00000011
1525087160038ms:redis消费了一个任务：消费的订单OrderId为OID00000012
1525087160045ms:redis消费了一个任务：消费的订单OrderId为OID00000012
1525087160048ms:redis消费了一个任务：消费的订单OrderId为OID00000012
1525087160053ms:redis消费了一个任务：消费的订单OrderId为OID00000013
1525087160064ms:redis消费了一个任务：消费的订单OrderId为OID00000013
1525087160065ms:redis消费了一个任务：消费的订单OrderId为OID00000014
1525087160069ms:redis消费了一个任务：消费的订单OrderId为OID00000014
当前没有等待的任务
当前没有等待的任务
当前没有等待的任务
当前没有等待的任务

显然，出现了多个线程消费同一个资源的情况。

解决方案

• (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.Jedis;
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+"订单取消");
  }
 }
}

输出如下

1525096202813ms:OID0000000订单生成
1525096202818ms:OID0000001订单生成
1525096202824ms:OID0000002订单生成
1525096202826ms:OID0000003订单生成
1525096202830ms:OID0000004订单生成
1525096202834ms:OID0000005订单生成
1525096202839ms:OID0000006订单生成
1525096205819ms:OID0000000订单取消
1525096205920ms:OID0000005订单取消
1525096205920ms:OID0000004订单取消
1525096205920ms:OID0000001订单取消
1525096205920ms:OID0000003订单取消
1525096205920ms:OID0000006订单取消
1525096205920ms:OID0000002订单取消

可以明显看到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)时间准确度高

缺点:(1)需要额外进行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,所以复杂度和成本变高