什么药可以延时30分钟不吃药能治好的方法推荐的方法(实现订单 30 分钟未支付则自动取消，五种方案！)

大家好，关于什么药可以延时30分钟不吃药能治好的方法推荐的方法很多朋友都还不太明白，今天小编就来为大家分享关于实现订单 30 分钟未支付则自动取消，五种方案！的知识，希望对各位有所帮助！

在开发中，往往会遇到一些关于延时任务的需求。例如

对上述的任务，我们给一个专业的名字来形容，那就是延时任务。那么这里就会产生一个问题，这个延时任务和定时任务的区别究竟在哪里呢？一共有如下几点区别

下面，我们以判断订单是否超时为例，进行方案分析

基于SpringBoot+MyBatisPlus+Vue&Element实现的后台管理系统+用户小程序，支持RBAC动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

项目地址：https://github.com/YunaiV/ruoyi-vue-pro

视频教程：https://doc.iocoder.cn/video/

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

博主当年早期是用quartz来实现的(实习那会的事)，简单介绍一下maven项目引入一个依赖如下所示

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

调用Demo类MyJob如下所示

packagecom.rjzheng.delay1;\n\nimportorg.quartz.JobBuilder;\nimportorg.quartz.JobDetail;\nimportorg.quartz.Scheduler;\nimportorg.quartz.SchedulerException;\nimportorg.quartz.SchedulerFactory;\nimportorg.quartz.SimpleScheduleBuilder;\nimportorg.quartz.Trigger;\nimportorg.quartz.TriggerBuilder;\nimportorg.quartz.impl.StdSchedulerFactory;\nimportorg.quartz.Job;\nimportorg.quartz.JobExecutionContext;\nimportorg.quartz.JobExecutionException;\n\npublicclassMyJobimplementsJob{\npublicvoidexecute(JobExecutionContextcontext)\nthrowsJobExecutionException{\nSystem.out.println("要去数据库扫描啦。。。");\n}\n\npublicstaticvoidmain(String[]args)throwsException{\n//创建任务\nJobDetailjobDetail=JobBuilder.newJob(MyJob.class)\n.withIdentity("job1","group1").build();\n//创建触发器每3秒钟执行一次\nTriggertrigger=TriggerBuilder\n.newTrigger()\n.withIdentity("trigger1","group3")\n.withSchedule(\nSimpleScheduleBuilder.simpleSchedule()\n.withIntervalInSeconds(3).repeatForever())\n.build();\nSchedulerscheduler=newStdSchedulerFactory().getScheduler();\n//将任务及其触发器放入调度器\nscheduler.scheduleJob(jobDetail,trigger);\n//调度器开始调度任务\nscheduler.start();\n}\n}\n

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

要去数据库扫描啦。。。\n优缺点

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

该方案是利用JDK自带的DelayQueue来实现，这是一个无界阻塞队列，该队列只有在延迟期满的时候才能从中获取元素，放入DelayQueue中的对象，是必须实现Delayed接口的。

DelayedQueue实现工作流程如下图所示

定义一个类OrderDelay实现Delayed，代码如下

packagecom.rjzheng.delay2;\n\nimportjava.util.concurrent.Delayed;\nimportjava.util.concurrent.TimeUnit;\n\npublicclassOrderDelayimplementsDelayed{\n\nprivateStringorderId;\nprivatelongtimeout;\n\nOrderDelay(StringorderId,longtimeout){\nthis.orderId=orderId;\nthis.timeout=timeout+System.nanoTime();\n}\n\npublicintcompareTo(Delayedother){\nif(other==this)\nreturn0;\nOrderDelayt=(OrderDelay)other;\nlongd=(getDelay(TimeUnit.NANOSECONDS)-t\n.getDelay(TimeUnit.NANOSECONDS));\nreturn(d==0)?0:((d<0)?-1:1);\n}\n\n//返回距离你自定义的超时时间还有多少\npubliclonggetDelay(TimeUnitunit){\nreturnunit.convert(timeout-System.nanoTime(),TimeUnit.NANOSECONDS);\n}\n\nvoidprint(){\nSystem.out.println(orderId+"编号的订单要删除啦。。。。");\n}\n}\n

运行的测试Demo为，我们设定延迟时间为3秒

packagecom.rjzheng.delay2;\n\nimportjava.util.ArrayList;\nimportjava.util.List;\nimportjava.util.concurrent.DelayQueue;\nimportjava.util.concurrent.TimeUnit;\n\npublicclassDelayQueueDemo{\npublicstaticvoidmain(String[]args){\n//TODOAuto-generatedmethodstub\nList<String>list=newArrayList<String>();\nlist.add("00000001");\nlist.add("00000002");\nlist.add("00000003");\nlist.add("00000004");\nlist.add("00000005");\nDelayQueue<OrderDelay>queue=newDelayQueue<OrderDelay>();\nlongstart=System.currentTimeMillis();\nfor(inti=0;i<5;i++){\n//延迟三秒取出\nqueue.put(newOrderDelay(list.get(i),\nTimeUnit.NANOSECONDS.convert(3,TimeUnit.SECONDS)));\ntry{\nqueue.take().print();\nSystem.out.println("After"+\n(System.currentTimeMillis()-start)+"MilliSeconds");\n}catch(InterruptedExceptione){\n//TODOAuto-generatedcatchblock\ne.printStackTrace();\n}\n}\n}\n\n}\n

输出如下

00000001编号的订单要删除啦。。。。\nAfter3003MilliSeconds\n00000002编号的订单要删除啦。。。。\nAfter6006MilliSeconds\n00000003编号的订单要删除啦。。。。\nAfter9006MilliSeconds\n00000004编号的订单要删除啦。。。。\nAfter12008MilliSeconds\n00000005编号的订单要删除啦。。。。\nAfter15009MilliSeconds\n

可以看到都是延迟3秒，订单被删除

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

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

时间轮算法可以类比于时钟，如上图箭头（指针）按某一个方向按固定频率轮动，每一次跳动称为一个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>\n<groupId>io.netty</groupId>\n<artifactId>netty-all</artifactId>\n<version>4.1.24.Final</version>\n</dependency>\n

测试代码HashedWheelTimerTest如下所示

packagecom.rjzheng.delay3;\n\nimportio.netty.util.HashedWheelTimer;\nimportio.netty.util.Timeout;\nimportio.netty.util.Timer;\nimportio.netty.util.TimerTask;\n\nimportjava.util.concurrent.TimeUnit;\n\npublicclassHashedWheelTimerTest{\nstaticclassMyTimerTaskimplementsTimerTask{\nbooleanflag;\npublicMyTimerTask(booleanflag){\nthis.flag=flag;\n}\npublicvoidrun(Timeouttimeout)throwsException{\n//TODOAuto-generatedmethodstub\nSystem.out.println("要去数据库删除订单了。。。。");\nthis.flag=false;\n}\n}\npublicstaticvoidmain(String[]argv){\nMyTimerTasktimerTask=newMyTimerTask(true);\nTimertimer=newHashedWheelTimer();\ntimer.newTimeout(timerTask,5,TimeUnit.SECONDS);\ninti=1;\nwhile(timerTask.flag){\ntry{\nThread.sleep(1000);\n}catch(InterruptedExceptione){\n//TODOAuto-generatedcatchblock\ne.printStackTrace();\n}\nSystem.out.println(i+"秒过去了");\ni++;\n}\n}\n}\n

输出如下

1秒过去了\n2秒过去了\n3秒过去了\n4秒过去了\n5秒过去了\n要去数据库删除订单了。。。。\n6秒过去了\n优缺点

优点:效率高,任务触发时间延迟时间比delayQueue低，代码复杂度比delayQueue低。

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

\n>基于SpringCloudAlibaba+Gateway+Nacos+RocketMQ+Vue&Element实现的后台管理系统+用户小程序，支持RBAC动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能\n>\n>*项目地址：<https://github.com/YunaiV/yudao-cloud>\n>*视频教程：<https://doc.iocoder.cn/video/>\n\n#添加单个元素\n\nredis>ZADDpage_rank10google.com\n(integer)1\n\n\n#添加多个元素\n\nredis>ZADDpage_rank9baidu.com8bing.com\n(integer)2\n\nredis>ZRANGEpage_rank0-1WITHSCORES\n1)"bing.com"\n2)"8"\n3)"baidu.com"\n4)"9"\n5)"google.com"\n6)"10"\n\n#查询元素的score值\nredis>ZSCOREpage_rankbing.com\n"8"\n\n#移除单个元素\n\nredis>ZREMpage_rankgoogle.com\n(integer)1\n\nredis>ZRANGEpage_rank0-1WITHSCORES\n1)"bing.com"\n2)"8"\n3)"baidu.com"\n4)"9"\n

那么如何实现呢？我们将订单超时时间戳与订单号分别设置为score和member,系统扫描第一个元素判断是否超时，具体如下图所示

packagecom.rjzheng.delay4;\n\nimportjava.util.Calendar;\nimportjava.util.Set;\n\nimportredis.clients.jedis.Jedis;\nimportredis.clients.jedis.JedisPool;\nimportredis.clients.jedis.Tuple;\n\npublicclassAppTest{\nprivatestaticfinalStringADDR="127.0.0.1";\nprivatestaticfinalintPORT=6379;\nprivatestaticJedisPooljedisPool=newJedisPool(ADDR,PORT);\n\npublicstaticJedisgetJedis(){\nreturnjedisPool.getResource();\n}\n\n//生产者,生成5个订单放进去\npublicvoidproductionDelayMessage(){\nfor(inti=0;i<5;i++){\n//延迟3秒\nCalendarcal1=Calendar.getInstance();\ncal1.add(Calendar.SECOND,3);\nintsecond3later=(int)(cal1.getTimeInMillis()/1000);\nAppTest.getJedis().zadd("OrderId",second3later,"OID0000001"+i);\nSystem.out.println(System.currentTimeMillis()+"ms:redis生成了一个订单任务：订单ID为"+"OID0000001"+i);\n}\n}\n\n//消费者，取订单\npublicvoidconsumerDelayMessage(){\nJedisjedis=AppTest.getJedis();\nwhile(true){\nSet<Tuple>items=jedis.zrangeWithScores("OrderId",0,1);\nif(items==null||items.isEmpty()){\nSystem.out.println("当前没有等待的任务");\ntry{\nThread.sleep(500);\n}catch(InterruptedExceptione){\n//TODOAuto-generatedcatchblock\ne.printStackTrace();\n}\ncontinue;\n}\nintscore=(int)((Tuple)items.toArray()[0]).getScore();\nCalendarcal=Calendar.getInstance();\nintnowSecond=(int)(cal.getTimeInMillis()/1000);\nif(nowSecond>=score){\nStringorderId=((Tuple)items.toArray()[0]).getElement();\njedis.zrem("OrderId",orderId);\nSystem.out.println(System.currentTimeMillis()+"ms:redis消费了一个任务：消费的订单OrderId为"+orderId);\n}\n}\n}\n\npublicstaticvoidmain(String[]args){\nAppTestappTest=newAppTest();\nappTest.productionDelayMessage();\nappTest.consumerDelayMessage();\n}\n\n}\n

此时对应输出如下

1525086085261ms:redis生成了一个订单任务：订单ID为OID00000010\n1525086085263ms:redis生成了一个订单任务：订单ID为OID00000011\n1525086085266ms:redis生成了一个订单任务：订单ID为OID00000012\n1525086085268ms:redis生成了一个订单任务：订单ID为OID00000013\n1525086085270ms:redis生成了一个订单任务：订单ID为OID00000014\n1525086088000ms:redis消费了一个任务：消费的订单OrderId为OID00000010\n1525086088001ms:redis消费了一个任务：消费的订单OrderId为OID00000011\n1525086088002ms:redis消费了一个任务：消费的订单OrderId为OID00000012\n1525086088003ms:redis消费了一个任务：消费的订单OrderId为OID00000013\n1525086088004ms:redis消费了一个任务：消费的订单OrderId为OID00000014\n当前没有等待的任务\n当前没有等待的任务\n当前没有等待的任务\n

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

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

packagecom.rjzheng.delay4;\n\nimportjava.util.concurrent.CountDownLatch;\n\npublicclassThreadTest{\nprivatestaticfinalintthreadNum=10;\nprivatestaticCountDownLatchcdl=newCountDownLatch(threadNum);\nstaticclassDelayMessageimplementsRunnable{\npublicvoidrun(){\ntry{\ncdl.await();\n}catch(InterruptedExceptione){\n//TODOAuto-generatedcatchblock\ne.printStackTrace();\n}\nAppTestappTest=newAppTest();\nappTest.consumerDelayMessage();\n}\n}\npublicstaticvoidmain(String[]args){\nAppTestappTest=newAppTest();\nappTest.productionDelayMessage();\nfor(inti=0;i<threadNum;i++){\nnewThread(newDelayMessage()).start();\ncdl.countDown();\n}\n}\n}\n

输出如下所示

1525087157727ms:redis生成了一个订单任务：订单ID为OID00000010\n1525087157734ms:redis生成了一个订单任务：订单ID为OID00000011\n1525087157738ms:redis生成了一个订单任务：订单ID为OID00000012\n1525087157747ms:redis生成了一个订单任务：订单ID为OID00000013\n1525087157753ms:redis生成了一个订单任务：订单ID为OID00000014\n1525087160009ms:redis消费了一个任务：消费的订单OrderId为OID00000010\n1525087160011ms:redis消费了一个任务：消费的订单OrderId为OID00000010\n1525087160012ms:redis消费了一个任务：消费的订单OrderId为OID00000010\n1525087160022ms:redis消费了一个任务：消费的订单OrderId为OID00000011\n1525087160023ms:redis消费了一个任务：消费的订单OrderId为OID00000011\n1525087160029ms:redis消费了一个任务：消费的订单OrderId为OID00000011\n1525087160038ms:redis消费了一个任务：消费的订单OrderId为OID00000012\n1525087160045ms:redis消费了一个任务：消费的订单OrderId为OID00000012\n1525087160048ms:redis消费了一个任务：消费的订单OrderId为OID00000012\n1525087160053ms:redis消费了一个任务：消费的订单OrderId为OID00000013\n1525087160064ms:redis消费了一个任务：消费的订单OrderId为OID00000013\n1525087160065ms:redis消费了一个任务：消费的订单OrderId为OID00000014\n1525087160069ms:redis消费了一个任务：消费的订单OrderId为OID00000014\n当前没有等待的任务\n当前没有等待的任务\n当前没有等待的任务\n当前没有等待的任务\n

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

if(nowSecond>=score){\nStringorderId=((Tuple)items.toArray()[0]).getElement();\njedis.zrem("OrderId",orderId);\nSystem.out.println(System.currentTimeMillis()+"ms:redis消费了一个任务：消费的订单OrderId为"+orderId);\n}\n

修改为

if(nowSecond>=score){\nStringorderId=((Tuple)items.toArray()[0]).getElement();\nLongnum=jedis.zrem("OrderId",orderId);\nif(num!=null&&num>0){\nSystem.out.println(System.currentTimeMillis()+"ms:redis消费了一个任务：消费的订单OrderId为"+orderId);\n}\n}\n

在这种修改后，重新运行ThreadTest类，发现输出正常了

该方案使用redis的KeyspaceNotifications，中文翻译就是键空间机制，就是利用该机制可以在key失效之后，提供一个回调，实际上是redis会给客户端发送一个消息。是需要redis版本2.8以上。

notify-keyspace-eventsEx\n

运行代码如下

packagecom.rjzheng.delay5;\n\nimportredis.clients.jedis.Jedis;\nimportredis.clients.jedis.JedisPool;\nimportredis.clients.jedis.JedisPubSub;\n\npublicclassRedisTest{\nprivatestaticfinalStringADDR="127.0.0.1";\nprivatestaticfinalintPORT=6379;\nprivatestaticJedisPooljedis=newJedisPool(ADDR,PORT);\nprivatestaticRedisSubsub=newRedisSub();\n\npublicstaticvoidinit(){\nnewThread(newRunnable(){\npublicvoidrun(){\njedis.getResource().subscribe(sub,"__keyevent@0__:expired");\n}\n}).start();\n}\n\npublicstaticvoidmain(String[]args)throwsInterruptedException{\ninit();\nfor(inti=0;i<10;i++){\nStringorderId="OID000000"+i;\njedis.getResource().setex(orderId,3,orderId);\nSystem.out.println(System.currentTimeMillis()+"ms:"+orderId+"订单生成");\n}\n}\n\nstaticclassRedisSubextendsJedisPubSub{\n@Override\npublicvoidonMessage(Stringchannel,Stringmessage){\nSystem.out.println(System.currentTimeMillis()+"ms:"+message+"订单取消");\n}\n}\n}\n

输出如下

1525096202813ms:OID0000000订单生成\n1525096202818ms:OID0000001订单生成\n1525096202824ms:OID0000002订单生成\n1525096202826ms:OID0000003订单生成\n1525096202830ms:OID0000004订单生成\n1525096202834ms:OID0000005订单生成\n1525096202839ms:OID0000006订单生成\n1525096205819ms:OID0000000订单取消\n1525096205920ms:OID0000005订单取消\n1525096205920ms:OID0000004订单取消\n1525096205920ms:OID0000001订单取消\n1525096205920ms:OID0000003订单取消\n1525096205920ms:OID0000006订单取消\n1525096205920ms:OID0000002订单取消\n

可以明显看到3秒过后，订单取消了

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

原:BecauseRedisPub/Subisfireandforgetcurrentlythereisnowaytousethisfeatureifyourapplicationdemandsreliablenotificationofevents,thatis,ifyourPub/Subclientdisconnects,andreconnectslater,alltheeventsdeliveredduringthetimetheclientwasdisconnectedarelost.

翻:Redis的发布/订阅目前是即发即弃(fireandforget)模式的，因此无法实现事件的可靠通知。也就是说，如果发布/订阅的客户端断链之后又重连，则在客户端断链期间的所有事件都丢失了。因此，方案二不是太推荐。当然，如果你对可靠性要求不高，可以使用。

我们可以采用rabbitMQ的延时队列。RabbitMQ具有以下两个特性，可以实现延迟队列

优点:高效,可以利用rabbitmq的分布式特性轻易的进行横向扩展,消息支持持久化增加了可靠性。缺点：本身的易用度要依赖于rabbitMq的运维.因为要引用rabbitMq,所以复杂度和成本变高

本文总结了目前互联网中，绝大部分的延时任务的实现方案。希望大家在工作中能够有所收获。

如果你还想了解更多这方面的信息，记得收藏关注本站。