Java JDK的DelayedQueue实现延迟任务

1. 场景及实现方式

在我们所遇到的业务需求中，其实有很多能用到延迟队列的场景：

• 现在网络的订单超时15分钟未付款将自动关闭
• 你编写了一篇博客，但你想明天早上再发布，你就可以设置定时发布博客
• 公众号为客户推送消息，设置延迟时间定时推送
• ...

 这种需求的实现方式也有多种多样：

• JDK提供了DelayedQueue延迟队列
• 数据库轮询
• Redis的zset有序集合数据特性
• Rabbit死信队列
• ...

2. JDK提供的DelayedQueue实现

 延迟队列管理器，用于管理及执行延迟任务

import com.sms.domain.entity.NewsManual;
import com.sms.domain.item.DelayTask;
import com.sms.domain.item.TaskBase;
import com.sms.service.InternalNewsService;
import com.sms.service.impl.NewsPushAsyncImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.concurrent.DelayQueue;
import java.util.concurrent.Executors;

/**
 * 延迟队列管理器
 */
@Component
@Slf4j
public class DelayQueueManagers implements CommandLineRunner {

  private final DelayQueue<DelayTask> delayQueue = new DelayQueue<>();

  @Autowired
  private InternalNewsService internalNewsService;

  @Autowired
  private NewsPushAsyncImpl newsPushAsyncImpl;

  /**
   * 加入到延时队列中
   *
   * @param task
   */
  public void put(DelayTask task) {
    log.info("加入延时任务：{}", task);
    delayQueue.put(task);
  }

  /**
   * 取消延时任务
   *
   * @param task
   * @return
   */
  public boolean remove(DelayTask task) {
    log.info("取消延时任务：{}", task);
    return delayQueue.remove(task);
  }

  /**
   * 取消延时任务
   *
   * @param taskid
   * @return
   */
  public boolean remove(String taskid) {
    return remove(new DelayTask(new TaskBase(taskid), 0));
  }

  /**
   * 任务执行器，到时间了自动执行任务
   * @param args
   * @throws Exception
   */
  @Override
  public void run(String... args) throws Exception {
    log.info("初始化延时队列");
    Executors.newSingleThreadExecutor().execute(new Thread(this::excuteThread));
  }

  /**
   * 延时任务执行线程
   */
  private void excuteThread() {
    while (true) {
      try {
        //从队列中拿出要执行的任务
        DelayTask task = delayQueue.take();
        processTask(task);
      } catch (Exception e) {
        break;
      }
    }
  }

  /**
   * 内部执行延时任务
   *
   * @param task
   */
  private void processTask(DelayTask task) throws Exception {
    log.info("执行延时任务：{}-{}", task, task.getData().getIdentifier());
    //获取任务标识符，一般为业务数据的主键id值
    String identifier = task.getData().getIdentifier();
    try {

      //拿到要执行的任务数据的id后，此处就可以根据自己的业务需求完成相应的逻辑
      //例如：下方的代码我是要将该业务数据作为消息异步推送出去
      NewsManual newsManual = internalNewsService.getById(Integer.parseInt(identifier));
      newsPushAsyncImpl.asyncPush(newsManual);

    }catch (Exception e){
      //如果捕获到异常，就将当前任务删除
      remove(identifier);
    }
  }
}

延迟任务实体类

import com.sms.util.DateUtils;

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

/**
 * 延迟任务实体类
 */
public class DelayTask implements Delayed {

    final private TaskBase data;

    //任务延时时间（ms）:从加入到延迟队列时开始计时，多少毫秒后执行该任务
    final private long expire;

    /**
     * 构造延时任务
     *
     * @param data   业务数据
     * @param expire 任务延时时间（ms）
     */
    public DelayTask(TaskBase data, long expire) {
        super();
        this.data = data;
        this.expire = expire + System.currentTimeMillis();
    }

    public TaskBase getData() {
        return data;
    }

    public long getExpire() {
        return expire;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof DelayTask) {
            return this.data.getIdentifier().equals(((DelayTask) obj).getData().getIdentifier());
        }
        return false;
    }

    @Override
    public String toString() {
        return "{" + "data:" + data.toString() + "," + "延时时间:" + DateUtils.getTimestampToTime(expire, DateUtils.YYYY_MM_DD_HH_MM_SS) + "}";
    }

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

    @Override
    public int compareTo(Delayed o) {
        long delta = getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
        return (int) delta;
    }
}

任务数据实体类

/**
 * 任务数据实体类
 */
public class TaskBase {

    //任务唯一表示，一般为业务数据主键id
    private String identifier;

    public TaskBase(String identifier) {
        this.identifier = identifier;
    }

    public String getIdentifier() {
        return identifier;
    }

    public void setIdentifier(String identifier) {
        this.identifier = identifier;
    }
}

日期格式转换工具类

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateUtils extends org.apache.commons.lang3.time.DateUtils {

    public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";

    public static String getTimestampToTime(Long timeStamp, final String ts) {
        SimpleDateFormat sdf = new SimpleDateFormat(ts);
        return sdf.format(new Date(Long.parseLong(String.valueOf(timeStamp))));
    }
}

 调用方式（这里根据自己的业务逻辑在合适的地方将延迟任务加入到延迟队列中）

@Resource
private DelayQueueManagers delayQueueManager;

@Override
@Transactional
public void save(NewsManual newsManual) throws Exception {
//此处根据自己的业务逻辑进行编写
    long p_time = sdf.parse(newsManuals.getPushTime()).getTime();//推送时间
    long d_time = p_time - System.currentTimeMillis();//延迟时间=推送时间-当前时间
    
    //新增任务加入到延迟任务队列
    delayQueueManager.put(
        new DelayTask(new TaskBase(newsManuals.getId().toString()), d_time)
    );
}

3. JDK提供的DelayedQueue延迟队列的优缺点

这种方式的优点就是实现简单，不复杂。

但是其缺点也比较多：不具备可扩展性，内存限制、无持久化机制，数据容易丢失。