延时队列实现的几种姿势

小哈学Java

共 6903字,需浏览 14分钟

 ·

2020-10-11 18:38

点击上方蓝色“小哈学Java”,选择“设为星标

回复“资源”获取独家整理的学习资料!

来源:r6d.cn/qE5f


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

  • 生成订单30分钟未支付,则自动取消

  • 生成订单60秒后,给用户发短信

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

1、 定时任务有明确的触发时间,延时任务没有 2、 定时任务有执行周期,而延时任务在某事件触发后一段时间内执行,没有执行周期 3、 定时任务一般执行的是批处理操作是多个任务,而延时任务一般是单个任务

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

1、 数据库轮询

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

实现

早期是用quartz来实现的
maven项目引入一个依赖如下所示:

  1.        org.quartz-scheduler

  2.        quartz

  3.        2.2.2

  4.    

调用Demo类MyJob如下所示

  1. package com.rjzheng.delay1;

  2. import org.quartz.JobBuilder;

  3. import org.quartz.JobDetail;

  4. import org.quartz.Scheduler;

  5. import org.quartz.SchedulerException;

  6. import org.quartz.SchedulerFactory;

  7. import org.quartz.SimpleScheduleBuilder;

  8. import org.quartz.Trigger;

  9. import org.quartz.TriggerBuilder;

  10. import org.quartz.impl.StdSchedulerFactory;

  11. import org.quartz.Job;

  12. import org.quartz.JobExecutionContext;

  13. import org.quartz.JobExecutionException;

  14. public class MyJob implements Job {

  15.    public void execute(JobExecutionContext context)

  16.            throws JobExecutionException {

  17.        System.out.println("要去数据库扫描啦。。。");

  18.    }

  19.    public static void main(String[] args) throws Exception {

  20.        // 创建任务

  21.        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)

  22.                .withIdentity("job1", "group1").build();

  23.        // 创建触发器 每3秒钟执行一次

  24.        Trigger trigger = TriggerBuilder

  25.                .newTrigger()

  26.                .withIdentity("trigger1", "group3")

  27.                .withSchedule(

  28.                        SimpleScheduleBuilder.simpleSchedule()

  29.                                .withIntervalInSeconds(3).repeatForever())

  30.                .build();

  31.        Scheduler scheduler = new StdSchedulerFactory().getScheduler();

  32.        // 将任务及其触发器放入调度器

  33.        scheduler.scheduleJob(jobDetail, trigger);

  34.        // 调度器开始调度任务

  35.        scheduler.start();

  36.    }

  37. }

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

  1. 要去数据库扫描啦。。。

优缺点

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

2、JDK的延迟队列

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

其中Poll():获取并移除队列的超时元素,没有则返回空
take():获取并移除队列的超时元素,如果没有则wait当前线程,直到有元素满足超时条件,返回结果。

实现

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

  1. package com.rjzheng.delay2;

  2. import java.util.concurrent.Delayed;

  3. import java.util.concurrent.TimeUnit;

  4. public class OrderDelay implements Delayed {

  5.    private String orderId;

  6.    private long timeout;

  7.    OrderDelay(String orderId, long timeout) {

  8.        this.orderId = orderId;

  9.        this.timeout = timeout + System.nanoTime();

  10.    }

  11.    public int compareTo(Delayed other) {

  12.        if (other == this)

  13.            return 0;

  14.        OrderDelay t = (OrderDelay) other;

  15.        long d = (getDelay(TimeUnit.NANOSECONDS) - t

  16.                .getDelay(TimeUnit.NANOSECONDS));

  17.        return (d == 0) ? 0 : ((d < 0) ? -1 : 1);

  18.    }

  19.    // 返回距离你自定义的超时时间还有多少

  20.    public long getDelay(TimeUnit unit) {

  21.        return unit.convert(timeout - System.nanoTime(), TimeUnit.NANOSECONDS);

  22.    }

  23.    void print() {

  24.        System.out.println(orderId+"编号的订单要删除啦。。。。");

  25.    }

  26. }

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

  1. package com.rjzheng.delay2;

  2. import java.util.ArrayList;

  3. import java.util.List;

  4. import java.util.concurrent.DelayQueue;

  5. import java.util.concurrent.TimeUnit;

  6. public class DelayQueueDemo {

  7.     public static void main(String[] args) {  

  8.            // TODO Auto-generated method stub  

  9.            List<String> list = new ArrayList<String>();  

  10.            list.add("00000001");  

  11.            list.add("00000002");  

  12.            list.add("00000003");  

  13.            list.add("00000004");  

  14.            list.add("00000005");  

  15.            DelayQueue<OrderDelay> queue = new DelayQueue<OrderDelay>();  

  16.            long start = System.currentTimeMillis();  

  17.            for(int i = 0;i<5;i++){  

  18.                //延迟三秒取出

  19.                queue.put(new OrderDelay(list.get(i),  

  20.                        TimeUnit.NANOSECONDS.convert(3, TimeUnit.SECONDS)));  

  21.                    try {  

  22.                         queue.take().print();  

  23.                         System.out.println("After " +  

  24.                                 (System.currentTimeMillis()-start) + " MilliSeconds");  

  25.                } catch (InterruptedException e) {  

  26.                    // TODO Auto-generated catch block  

  27.                    e.printStackTrace();  

  28.                }  

  29.            }  

  30.        }  

  31. }

输出如下

  1. 00000001编号的订单要删除啦。。。。

  2. After 3003 MilliSeconds

  3. 00000002编号的订单要删除啦。。。。

  4. After 6006 MilliSeconds

  5. 00000003编号的订单要删除啦。。。。

  6. After 9006 MilliSeconds

  7. 00000004编号的订单要删除啦。。。。

  8. After 12008 MilliSeconds

  9. 00000005编号的订单要删除啦。。。。

  10. After 15009 MilliSeconds

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

优缺点

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

3、netty时间轮算法

时间轮的图

时间轮算法可以类比于时钟,如上图箭头(指针)按某一个方向按固定频率轮动,每一次跳动称为一个 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加上下面的依赖

  1.            io.netty

  2.            netty-all

  3.            4.1.24.Final

测试代码HashedWheelTimerTest如下所示

  1. package com.rjzheng.delay3;

  2. import io.netty.util.HashedWheelTimer;

  3. import io.netty.util.Timeout;

  4. import io.netty.util.Timer;

  5. import io.netty.util.TimerTask;

  6. import java.util.concurrent.TimeUnit;

  7. public class HashedWheelTimerTest {

  8.    static class MyTimerTask implements TimerTask{

  9.        boolean flag;

  10.        public MyTimerTask(boolean flag){

  11.            this.flag = flag;

  12.        }

  13.        public void run(Timeout timeout) throws Exception {

  14.            // TODO Auto-generated method stub

  15.             System.out.println("要去数据库删除订单了。。。。");

  16.             this.flag =false;

  17.        }

  18.    }

  19.    public static void main(String[] argv) {

  20.        MyTimerTask timerTask = new MyTimerTask(true);

  21.        Timer timer = new HashedWheelTimer();

  22.        timer.newTimeout(timerTask, 5, TimeUnit.SECONDS);

  23.        int i = 1;

  24.        while(timerTask.flag){

  25.            try {

  26.                Thread.sleep(1000);

  27.            } catch (InterruptedException e) {

  28.                // TODO Auto-generated catch block

  29.                e.printStackTrace();

  30.            }

  31.            System.out.println(i+"秒过去了");

  32.            i++;

  33.        }

  34.    }

  35. }

输出如下

  1. 1秒过去了

  2. 2秒过去了

  3. 3秒过去了

  4. 4秒过去了

  5. 5秒过去了

  6. 要去数据库删除订单了。。。。

  7. 6秒过去了

优缺点

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

4、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 ...]
测试如下

  1. # 添加单个元素

  2. redis> ZADD page_rank 10 google.com

  3. (integer) 1

  4. # 添加多个元素

  5. redis> ZADD page_rank 9 baidu.com 8 bing.com

  6. (integer) 2

  7. redis> ZRANGE page_rank 0 -1 WITHSCORES

  8. 1) "bing.com"

  9. 2) "8"

  10. 3) "baidu.com"

  11. 4) "9"

  12. 5) "google.com"

  13. 6) "10"

  14. # 查询元素的score值

  15. redis> ZSCORE page_rank bing.com

  16. "8"

  17. # 移除单个元素

  18. redis> ZREM page_rank google.com

  19. (integer) 1

  20. redis> ZRANGE page_rank 0 -1 WITHSCORES

  21. 1) "bing.com"

  22. 2) "8"

  23. 3) "baidu.com"

  24. 4) "9"

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

实现一

  1. package com.rjzheng.delay4;

  2. import java.util.Calendar;

  3. import java.util.Set;

  4. import redis.clients.jedis.Jedis;

  5. import redis.clients.jedis.JedisPool;

  6. import redis.clients.jedis.Tuple;

  7. public class AppTest {

  8.    private static final String ADDR = "127.0.0.1";

  9.    private static final int PORT = 6379;

  10.    private static JedisPool jedisPool = new JedisPool(ADDR, PORT);

  11.    public static Jedis getJedis() {

  12.       return jedisPool.getResource();

  13.    }

  14.    //生产者,生成5个订单放进去

  15.    public void productionDelayMessage(){

  16.        for(int i=0;i<5;i++){

  17.            //延迟3秒

  18.            Calendar cal1 = Calendar.getInstance();

  19.            cal1.add(Calendar.SECOND, 3);

  20.            int second3later = (int) (cal1.getTimeInMillis() / 1000);

  21.            AppTest.getJedis().zadd("OrderId", second3later,"OID0000001"+i);

  22.            System.out.println(System.currentTimeMillis()+"ms:redis生成了一个订单任务:订单ID为"+"OID0000001"+i);

  23.        }

  24.    }

  25.    //消费者,取订单

  26.    public void consumerDelayMessage(){

  27.        Jedis jedis = AppTest.getJedis();

  28.        while(true){

  29.            Set<Tuple> items = jedis.zrangeWithScores("OrderId", 0, 1);

  30.            if(items == null || items.isEmpty()){

  31.                System.out.println("当前没有等待的任务");

  32.                try {

  33.                    Thread.sleep(500);

  34.                } catch (InterruptedException e) {

  35.                    // TODO Auto-generated catch block

  36.                    e.printStackTrace();

  37.                }

  38.                continue;

  39.            }

  40.            int  score = (int) ((Tuple)items.toArray()[0]).getScore();

  41.            Calendar cal = Calendar.getInstance();

  42.            int nowSecond = (int) (cal.getTimeInMillis() / 1000);

  43.            if(nowSecond >= score){

  44.                String orderId = ((Tuple)items.toArray()[0]).getElement();

  45.                jedis.zrem("OrderId", orderId);

  46.                System.out.println(System.currentTimeMillis() +"ms:redis消费了一个任务:消费的订单OrderId为"+orderId);

  47.            }

  48.        }

  49.    }

  50.    public static void main(String[] args) {

  51.        AppTest appTest =new AppTest();

  52.        appTest.productionDelayMessage();

  53.        appTest.consumerDelayMessage();

  54.    }

  55. }

此时对应输出如下

  1. 1525086085261ms:redis生成了一个订单任务:订单IDOID00000010

  2. 1525086085263ms:redis生成了一个订单任务:订单IDOID00000011

  3. 1525086085266ms:redis生成了一个订单任务:订单IDOID00000012

  4. 1525086085268ms:redis生成了一个订单任务:订单IDOID00000013

  5. 1525086085270ms:redis生成了一个订单任务:订单IDOID00000014

  6. 1525086088000ms:redis消费了一个任务:消费的订单OrderIdOID00000010

  7. 1525086088001ms:redis消费了一个任务:消费的订单OrderIdOID00000011

  8. 1525086088002ms:redis消费了一个任务:消费的订单OrderIdOID00000012

  9. 1525086088003ms:redis消费了一个任务:消费的订单OrderIdOID00000013

  10. 1525086088004ms:redis消费了一个任务:消费的订单OrderIdOID00000014

  11. 当前没有等待的任务

  12. 当前没有等待的任务

  13. 当前没有等待的任务

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

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

  1. package com.rjzheng.delay4;

  2. import java.util.concurrent.CountDownLatch;

  3. public class ThreadTest {

  4.    private static final int threadNum = 10;

  5.    private static CountDownLatch cdl = new CountDownLatch(threadNum);

  6.    static class DelayMessage implements Runnable{

  7.        public void run() {

  8.            try {

  9.                cdl.await();

  10.            } catch (InterruptedException e) {

  11.                // TODO Auto-generated catch block

  12.                e.printStackTrace();

  13.            }

  14.            AppTest appTest =new AppTest();

  15.            appTest.consumerDelayMessage();

  16.        }

  17.    }

  18.    public static void main(String[] args) {

  19.        AppTest appTest =new AppTest();

  20.        appTest.productionDelayMessage();

  21.        for(int i=0;i<threadNum;i++){

  22.            new Thread(new DelayMessage()).start();

  23.            cdl.countDown();

  24.        }

  25.    }

  26. }

输出如下所示

  1. 1525087157727ms:redis生成了一个订单任务:订单IDOID00000010

  2. 1525087157734ms:redis生成了一个订单任务:订单IDOID00000011

  3. 1525087157738ms:redis生成了一个订单任务:订单IDOID00000012

  4. 1525087157747ms:redis生成了一个订单任务:订单IDOID00000013

  5. 1525087157753ms:redis生成了一个订单任务:订单IDOID00000014

  6. 1525087160009ms:redis消费了一个任务:消费的订单OrderIdOID00000010

  7. 1525087160011ms:redis消费了一个任务:消费的订单OrderIdOID00000010

  8. 1525087160012ms:redis消费了一个任务:消费的订单OrderIdOID00000010

  9. 1525087160022ms:redis消费了一个任务:消费的订单OrderIdOID00000011

  10. 1525087160023ms:redis消费了一个任务:消费的订单OrderIdOID00000011

  11. 1525087160029ms:redis消费了一个任务:消费的订单OrderIdOID00000011

  12. 1525087160038ms:redis消费了一个任务:消费的订单OrderIdOID00000012

  13. 1525087160045ms:redis消费了一个任务:消费的订单OrderIdOID00000012

  14. 1525087160048ms:redis消费了一个任务:消费的订单OrderIdOID00000012

  15. 1525087160053ms:redis消费了一个任务:消费的订单OrderIdOID00000013

  16. 1525087160064ms:redis消费了一个任务:消费的订单OrderIdOID00000013

  17. 1525087160065ms:redis消费了一个任务:消费的订单OrderIdOID00000014

  18. 1525087160069ms:redis消费了一个任务:消费的订单OrderIdOID00000014

  19. 当前没有等待的任务

  20. 当前没有等待的任务

  21. 当前没有等待的任务

  22. 当前没有等待的任务

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

解决方案

(1)用分布式锁,但是用分布式锁,性能下降了,该方案不细说。
(2)对ZREM的返回值进行判断,只有大于0的时候,才消费数据,于是将consumerDelayMessage()方法里的

  1. if(nowSecond >= score){

  2.    String orderId = ((Tuple)items.toArray()[0]).getElement();

  3.    jedis.zrem("OrderId", orderId);

  4.    System.out.println(System.currentTimeMillis()+"ms:redis消费了一个任务:消费的订单OrderId为"+orderId);

  5. }

修改为

  1. if(nowSecond >= score){

  2.    String orderId = ((Tuple)items.toArray()[0]).getElement();

  3.    Long num = jedis.zrem("OrderId", orderId);

  4.    if( num != null && num>0){

  5.        System.out.println(System.currentTimeMillis()+"ms:redis消费了一个任务:消费的订单OrderId为"+orderId);

  6.    }

  7. }

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

思路二

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

实现二

在redis.conf中,加入一条配置

  1. notify-keyspace-events Ex

运行代码如下

  1. package com.rjzheng.delay5;

  2. import redis.clients.jedis.Jedis;

  3. import redis.clients.jedis.JedisPool;

  4. import redis.clients.jedis.JedisPubSub;

  5. public class RedisTest {

  6.    private static final String ADDR = "127.0.0.1";

  7.    private static final int PORT = 6379;

  8.    private static JedisPool jedis = new JedisPool(ADDR, PORT);

  9.    private static RedisSub sub = new RedisSub();

  10.    public static void init() {

  11.        new Thread(new Runnable() {

  12.            public void run() {

  13.                jedis.getResource().subscribe(sub, "__keyevent@0__:expired");

  14.            }

  15.        }).start();

  16.    }

  17.    public static void main(String[] args) throws InterruptedException {

  18.        init();

  19.        for(int i =0;i<10;i++){

  20.            String orderId = "OID000000"+i;

  21.            jedis.getResource().setex(orderId, 3, orderId);

  22.            System.out.println(System.currentTimeMillis()+"ms:"+orderId+"订单生成");

  23.        }

  24.    }

  25.    static class RedisSub extends JedisPubSub {

  26.        @Override

  27.        public void onMessage(String channel, String message) {

  28.            System.out.println(System.currentTimeMillis()+"ms:"+message+"订单取消");

  29.        }

  30.    }

  31. }

输出如下

  1. 1525096202813ms:OID0000000订单生成

  2. 1525096202818ms:OID0000001订单生成

  3. 1525096202824ms:OID0000002订单生成

  4. 1525096202826ms:OID0000003订单生成

  5. 1525096202830ms:OID0000004订单生成

  6. 1525096202834ms:OID0000005订单生成

  7. 1525096202839ms:OID0000006订单生成

  8. 1525096205819ms:OID0000000订单取消

  9. 1525096205920ms:OID0000005订单取消

  10. 1525096205920ms:OID0000004订单取消

  11. 1525096205920ms:OID0000001订单取消

  12. 1525096205920ms:OID0000003订单取消

  13. 1525096205920ms:OID0000006订单取消

  14. 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,所以复杂度和成本变高

6、总结

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

其实大家在工作中,百分九十的人还是以业务逻辑为主,很少有机会能够进行方案设计。所以博主不推荐在分布式这块,花太多时间。不过,鉴于现在的面试造火箭,工作拧螺丝现象太过严重,所以,最后来个小漫画娱乐一下。

END


有热门推荐?

1. 厉害!某生鲜电商平台竟然是这样设计监控模块的(已开源)~

2. 百度网盘突然大调整,网友炸了..

3. 图解 SQL,这也太形象了吧!

4. 《最受欢迎的女友职业排行榜Top10》

最近面试BAT,整理一份面试资料Java面试BATJ通关手册,覆盖了Java核心技术、JVM、Java并发、SSM、微服务、数据库、数据结构等等。

获取方式:点“在看”,关注公众号并回复 Java 领取,更多内容陆续奉上。

文章有帮助的话,在看,转发吧。

谢谢支持哟 (*^__^*)

浏览 35
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报