DelayQueue延迟处理任务记录一下

最新推荐文章于 2022-08-18 13:17:36 发布

IAmZRH

最新推荐文章于 2022-08-18 13:17:36 发布

阅读量474

点赞数 2

分类专栏： JAVA 文章标签：队列 java

本文链接：https://blog.csdn.net/qq_41665452/article/details/116090337

版权

JAVA 专栏收录该内容

42 篇文章 0 订阅

订阅专栏

DelayQueue延迟处理任务

前言

在工作中经常会遇到需要延迟处理某些消息的业务场景，比如订单超时，延迟通知，任务延迟处理等等。
实现方式有多种，包括使用rabbitMQ死信队列处理，jdk的DelayQueue延迟队列，redission的延迟队列。
本次介绍DelayQueue队列的使用及其实现原理。

过程

使用DelayQueue延迟队列，需要加入队列对象实现Delayed接口，重写getDelay()方法和compareTo()方法；
getDelay()方法是用于返回剩余过期时间，如果为小于等于0那就可以获取队列里的数据。
compareTo()方法是用于判断在队列中的排序位置。

/**
 * 延迟队列实现
 *
 * @AUTHOR ZRH
 * @DATE 2021/4/24 0024
 */
public class Test2 {

    public static void main(String[] args) {
        DelayQueue<luoDelayed> delayQueue = new DelayQueue<>();
        // 启动一个线程，循环获取队列里面的数据
        new Thread(() -> {
            while (true) {
                try {
                	// 阻塞式获取队列数据，如果没有就一直阻塞着
                    luoDelayed take = delayQueue.take();
                    System.out.println("获取延迟队列数据：" + take.toString());
                } catch (Exception e) {
                    System.err.println("异常。。。");
                }
            }
        }).start();

        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            long time = System.currentTimeMillis();
            luoDelayed luoDelayed = new luoDelayed();
            luoDelayed.setValue(i);
            luoDelayed.setEndTime(time + random.nextInt(2000) + 5000);
            luoDelayed.setStartTime(time);
            // 添加数据到队列里，过期时间至少是5秒后
            delayQueue.offer(luoDelayed);
        }
    }
}

@Data
class luoDelayed implements Delayed {

    private Integer value;
    private Long endTime;
    private Long startTime;

    /**
     * 返回剩余过期时间
     *
     * @param unit
     * @return
     */
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(endTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    /**
     * 判断在队列中的排序位置
     *
     * @param o
     * @return
     */
    @Override
    public int compareTo(Delayed o) {
        return (int) (endTime - ((luoDelayed) o).getEndTime());
    }

    @Override
    public String toString() {
        return "luoDelayed(value=" + value + ",endTime=" + endTime + ")，耗时=" + (System.currentTimeMillis() - startTime);
    }
}
--------------------------------
执行结果：
获取延迟队列数据：luoDelayed(value=2,endTime=1619242103316)，耗时=5010
获取延迟队列数据：luoDelayed(value=7,endTime=1619242103406)，耗时=5101
获取延迟队列数据：luoDelayed(value=1,endTime=1619242103697)，耗时=5392
获取延迟队列数据：luoDelayed(value=6,endTime=1619242103714)，耗时=5409
获取延迟队列数据：luoDelayed(value=3,endTime=1619242104063)，耗时=5758
获取延迟队列数据：luoDelayed(value=9,endTime=1619242104950)，耗时=6645
获取延迟队列数据：luoDelayed(value=4,endTime=1619242104954)，耗时=6649
获取延迟队列数据：luoDelayed(value=8,endTime=1619242104993)，耗时=6687
获取延迟队列数据：luoDelayed(value=5,endTime=1619242105117)，耗时=6812
获取延迟队列数据：luoDelayed(value=0,endTime=1619242105208)，耗时=6904

简单探究下其延迟实现原理：

    /**
     * Inserts the specified element into this delay queue.
     *
     * @param e the element to add
     * @return {@code true}
     * @throws NullPointerException if the specified element is null
     */
    public boolean offer(E e) {
    	// 加锁操作
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
        	// 往队列中添加一个数据，判断是否是队首数据
        	// 如果是，leader设置为null，并唤醒其他等待阻塞中的线程
            q.offer(e);
            if (q.peek() == e) {
                leader = null;
                available.signal();
            }
            return true;
        } finally {
            lock.unlock();
        }
    }
    
	/**
     * Retrieves and removes the head of this queue, waiting if necessary
     * until an element with an expired delay is available on this queue.
     *
     * @return the head of this queue
     * @throws InterruptedException {@inheritDoc}
     */
    public E take() throws InterruptedException {
    	// 获取锁
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
        	// 
            for (;;) {
            	// 取出队列的队首数据
                E first = q.peek();
                if (first == null)
                	// 如果队列没有数据，就等待(阻塞)，在加入数据到队列时被唤醒
                    available.await();
                else {
                	// 如果队列不为空，就获取队列剩余过期时间，如果剩余过期时间小于等于0，就直接返回数据对象
                    long delay = first.getDelay(NANOSECONDS);
                    if (delay <= 0)
                        return q.poll();
                    // 释放first的引用，防止内存泄漏
                    first = null; // don't retain ref while waiting
                    // leader不为null，阻塞线程
                    if (leader != null)
                        available.await();
                    else {
                    	// 把当前线程赋值给leader 
                        Thread thisThread = Thread.currentThread();
                        leader = thisThread;
                        try {
                        	// awaitNanos：等待经过delay纳秒后会自动唤醒，这时队首的数据就正好过期可以取出
                            available.awaitNanos(delay);
                        } finally {
                        	// 释放leader的引用
                            if (leader == thisThread)
                                leader = null;
                        }
                    }
                }
            }
        } finally {
        	// 解锁操作，并且如果leader为null且队列不为null的情况下，用signal唤醒其他等待的线程。
            if (leader == null && q.peek() != null)
                available.signal();
            lock.unlock();
        }
    }

这里解释下first的内存泄漏情况 :

first = null; // don’t retain ref while waiting

因为在多消费端调用take()方法时，如果线程A获取first = q.peek()并且进入后面的else流程把leader设置为自身线程，线程B也获取first = q.peek()然后阻塞了。
线程A把到期的对象poll出去，这时对象应该被GC回收掉。但是它还被线程B的first引用着，所以不能被GC掉。
如果还有其他的线程一直对first引用着，那么就会造成内存泄漏。

这里解释下leader的作用 :

    /**
     * Thread designated to wait for the element at the head of
     * the queue.  This variant of the Leader-Follower pattern
     * (http://www.cs.wustl.edu/~schmidt/POSA/POSA2/) serves to
     * minimize unnecessary timed waiting.  When a thread becomes
     * the leader, it waits only for the next delay to elapse, but
     * other threads await indefinitely.  The leader thread must
     * signal some other thread before returning from take() or
     * poll(...), unless some other thread becomes leader in the
     * interim.  Whenever the head of the queue is replaced with
     * an element with an earlier expiration time, the leader
     * field is invalidated by being reset to null, and some
     * waiting thread, but not necessarily the current leader, is
     * signalled.  So waiting threads must be prepared to acquire
     * and lose leadership while waiting.
     */
    private Thread leader = null;