BlockingQueue队列之DelayQueue

1、基本概念

DelayQueue是一个无界的BlockingQueue，它本质就是封装了一个PriorityQueue（优先队列），用于放置实现了Delayed接口的对象，其中的对象只能在其到期时才能从队列中取走。这种队列是有序的，即队头对象的延迟到期时间最长。

注意：不能将null元素放置到DelayQueue队列中。

2、DelayQueue能做什么

1、淘宝订单业务，下单超过30分钟没有付款就自动取消订单（过期订单自动取消）。
2、淘宝新建商户一个月内还没上传商品信息，将冻结商铺等。
3、饿了吗订餐通知，下单成功60s之后给用户发送短信通知。
4、关闭空闲连接，服务器中，有很多客户端的连接，空闲一段时间之后需要关闭。
5、缓存，缓存中的对象，超过了空闲时间，需要从缓存中移出。
6、业务在指定的具体时间执行（也可以作为延迟任务处理）。

3、实例展示

DelayQueue只能添加(offer/put/add)实现了Delayed接口的对象，所以先定义一个实现了Delayed接口的对象

package com.wzl;

import java.util.Date;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * 元素类
 * 必须是实现了Delayed接口的对象
 * 该接口需要实现compareTo和getDelay方法
 *
 * @param <T>
 */
public class ItemDelayed<T> implements Delayed {
    
    /**
     * 默认延迟1分钟
     */
    private final static long DELAY = 1 * 60 * 1000L;

    /**
     * 数据id
     */
    private Long dataId;

    /**
     * 开始时间
     */
    private long startTime;

    /**
     * 到期时间
     */
    private long expire;

    /**
     * 创建时间
     */
    private Date now;

    /**
     * 泛型data
     */
    private T data;

    public ItemDelayed(Long dataId, long startTime) {
        super();
        this.dataId = dataId;
        this.startTime = startTime;
        this.expire = startTime + DELAY;
        this.now = new Date();
    }

    public ItemDelayed(Long dataId, long startTime, long secondsDelay) {
        super();
        this.dataId = dataId;
        this.startTime = startTime;
        this.expire = startTime + (secondsDelay * 1000);
        this.now = new Date();
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(this.expire - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
    }


    public Long getDataId() {
        return dataId;
    }

    public void setDataId(Long dataId) {
        this.dataId = dataId;
    }

    public long getStartTime() {
        return startTime;
    }

    public void setStartTime(long startTime) {
        this.startTime = startTime;
    }

    public long getExpire() {
        return expire;
    }

    public void setExpire(long expire) {
        this.expire = expire;
    }

    public Date getNow() {
        return now;
    }

    public void setNow(Date now) {
        this.now = now;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

通用的接口,用于规范和方便统一DelayQueue的操作

package com.wzl;

/**
 * 通用的接口,用于规范和方便统一DelayQueue的操作
 * 这样任何类型的T对象都可以实现这个接口 进行延时任务的处理
 *
 * @param <T>
 */
public interface DelayTask<T> {

    /**
     * 添加延迟对象到延时队列
     *
     * @param itemDelayed 延迟对象
     * @return boolean
     */
    boolean addToDelayQueue(ItemDelayed<T> itemDelayed);

    /**
     * 根据对象添加到指定延时队列
     *
     * @param data 数据对象
     * @return boolean
     */
    boolean addToDelayQueue(T data);

    /**
     * 移除指定的延迟对象从延时队列中
     *
     * @param data
     */
    void removeToDelayQueue(T data);

}

MyTask是ItemDelayed所要承载的数据对象

package com.wzl;

import java.io.Serializable;
import java.util.Date;

/**
 * 数据对象
 */
public class MyTask implements Serializable {

    private static final long serialVersionUID = 7796575369292716175L;

    private Long id;

    private Date createDate;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }
}

基于DelayTask接口的具体实现

package com.wzl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@Component
public class DelayTaskImpl implements DelayTask<MyTask> {

    private static final Logger log = LoggerFactory.getLogger(DelayTaskImpl.class);

    /**
     * 创建一个单线程化线程池
     */
    private ExecutorService delayExecutor = Executors.newSingleThreadExecutor();

    private final static DelayQueue<ItemDelayed<MyTask>> DELAY_QUEUE = new DelayQueue<>();

    @PostConstruct
    public void init() {
        log.info("系统启动:扫描数据库未处理的任务!");
        List<MyTask> taskList = this.getTask();
        for (MyTask myTask : taskList) {
            ItemDelayed<MyTask> itemDelayed = new ItemDelayed<>(myTask.getId(), myTask.getCreateDate().getTime());
            this.addToDelayQueue(itemDelayed);
        }
        log.info("系统启动:扫描数据库未处理的任务,总共扫描了" + taskList.size() + "个,推入延迟队列，准备到期后处理!");

        /*使用一个单例线程，去取延迟任务*/
        delayExecutor.execute(() -> {
            log.info("启动处理的延迟队列的线程:" + Thread.currentThread().getName());
            ItemDelayed<MyTask> myTaskDelayed;
            while (true) {
                try {
                    //take()阻塞方式获取
                    myTaskDelayed = DELAY_QUEUE.take();
                    //处理延迟任务...
                    System.out.println(new Date() + "处理延迟任务:" + myTaskDelayed.getDataId());

                } catch (Exception e) {
                    log.error("处理延迟队列异常!", e);
                }
            }
        });
    }

    @Override
    public boolean addToDelayQueue(ItemDelayed<MyTask> itemDelayed) {
        return DELAY_QUEUE.add(itemDelayed);
    }

    @Override
    public boolean addToDelayQueue(MyTask data) {
        ItemDelayed<MyTask> myTaskDelayed = new ItemDelayed<>(data.getId(), data.getCreateDate().getTime());
        return DELAY_QUEUE.add(myTaskDelayed);
    }

    @Override
    public void removeToDelayQueue(MyTask data) {
        if (data == null) {
            return;
        }
        for (Iterator<ItemDelayed<MyTask>> iterator = DELAY_QUEUE.iterator(); iterator.hasNext(); ) {
            ItemDelayed<MyTask> queue = iterator.next();
            if (queue.getDataId().equals(data.getId())) {
                DELAY_QUEUE.remove(queue);
            }
        }
    }

    private List<MyTask> getTask() {
        List<MyTask> taskList = new ArrayList<>();
        //第一个任务创建时间设置为1分钟后
        MyTask t1 = new MyTask();
        t1.setId(10001L);
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.MINUTE, 1);
        t1.setCreateDate(calendar.getTime());

        //第2个任务过期时间设置为当前时间
        MyTask t2 = new MyTask();
        t2.setId(10002L);
        t2.setCreateDate(new Date());

        taskList.add(t1);
        taskList.add(t2);
        return taskList;
    }

}

运行效果