java利用delayedQueue實現(xiàn)本地的延遲隊列

更新時間：2017年04月23日 11:41:18 作者：jsondream

這篇文章主要給大家介紹了java利用delayedQueue實現(xiàn)本地的延遲隊列的相關資料，文中介紹的非常詳細，相信對大家具有一定的參考價值，需要的朋友們下面來一起看看吧。

一、了解DelayQueue

DelayQueue是什么？

DelayQueue是一個無界的BlockingQueue，用于放置實現(xiàn)了Delayed接口的對象，其中的對象只能在其到期時才能從隊列中取走。這種隊列是有序的，即隊頭對象的延遲到期時間最長。

注意：不能將null元素放置到這種隊列中。

DelayQueue能做什么？

在我們的業(yè)務中通常會有一些需求是這樣的：

淘寶訂單業(yè)務:下單之后如果三十分鐘之內(nèi)沒有付款就自動取消訂單。
餓了嗎訂餐通知:下單成功后60s之后給用戶發(fā)送短信通知。

那么這類業(yè)務我們可以總結出一個特點:需要延遲工作。
由此的情況，就是我們的DelayQueue應用需求的產(chǎn)生。

二、怎么用DelayQueue來解決這類的問題

先聲明一個Delayed的對象

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

/**
 * <p>
 * [任務調(diào)度系統(tǒng)]
 * <br>
 * [隊列中要執(zhí)行的任務]
 * </p>
 *
 * @author wangguangdong
 * @version 1.0
 * @Date 2015年11月22日19:46:39
 */
public class Task<T extends Runnable> implements Delayed {
 /**
  * 到期時間
  */
 private final long time;

 /**
  * 問題對象
  */
 private final T task;
 private static final AtomicLong atomic = new AtomicLong(0);

 private final long n;

 public Task(long timeout, T t) {
  this.time = System.nanoTime() + timeout;
  this.task = t;
  this.n = atomic.getAndIncrement();
 }

 /**
  * 返回與此對象相關的剩余延遲時間，以給定的時間單位表示
  */
 @Override
 public long getDelay(TimeUnit unit) {
  return unit.convert(this.time - System.nanoTime(), TimeUnit.NANOSECONDS);
 }

 @Override
 public int compareTo(Delayed other) {
  // TODO Auto-generated method stub
  if (other == this) // compare zero ONLY if same object
   return 0;
  if (other instanceof Task) {
   Task x = (Task) other;
   long diff = time - x.time;
   if (diff < 0)
    return -1;
   else if (diff > 0)
    return 1;
   else if (n < x.n)
    return -1;
   else
    return 1;
  }
  long d = (getDelay(TimeUnit.NANOSECONDS) - other.getDelay(TimeUnit.NANOSECONDS));
  return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
 }

 public T getTask() {
  return this.task;
 }

 @Override
 public int hashCode() {
  return task.hashCode();
 }

 @Override
 public boolean equals(Object object) {
  if (object instanceof Task) {
   return object.hashCode() == hashCode() ? true : false;
  }
  return false;
 }


}

再實現(xiàn)一個管理延遲任務的類

import org.apache.log4j.Logger;

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

/**
 * <p>
 * [任務調(diào)度系統(tǒng)]
 * <br>
 * [后臺守護線程不斷的執(zhí)行檢測工作]
 * </p>
 *
 * @author wangguangdong
 * @version 1.0
 * @Date 2015年11月23日14:19:40
 */
public class TaskQueueDaemonThread {

 private static final Logger LOG = Logger.getLogger(TaskQueueDaemonThread.class);

 private TaskQueueDaemonThread() {
 }

 private static class LazyHolder {
  private static TaskQueueDaemonThread taskQueueDaemonThread = new TaskQueueDaemonThread();
 }

 public static TaskQueueDaemonThread getInstance() {
  return LazyHolder.taskQueueDaemonThread;
 }

 Executor executor = Executors.newFixedThreadPool(20);
 /**
  * 守護線程
  */
 private Thread daemonThread;

 /**
  * 初始化守護線程
  */
 public void init() {
  daemonThread = new Thread(() -> execute());
  daemonThread.setDaemon(true);
  daemonThread.setName("Task Queue Daemon Thread");
  daemonThread.start();
 }

 private void execute() {
  System.out.println("start:" + System.currentTimeMillis());
  while (true) {
   try {
    //從延遲隊列中取值,如果沒有對象過期則隊列一直等待，
    Task t1 = t.take();
    if (t1 != null) {
     //修改問題的狀態(tài)
     Runnable task = t1.getTask();
     if (task == null) {
      continue;
     }
     executor.execute(task);
     LOG.info("[at task:" + task + "] [Time:" + System.currentTimeMillis() + "]");
    }
   } catch (Exception e) {
    e.printStackTrace();
    break;
   }
  }
 }

 /**
  * 創(chuàng)建一個最初為空的新 DelayQueue
  */
 private DelayQueue<Task> t = new DelayQueue<>();

 /**
  * 添加任務，
  * time 延遲時間
  * task 任務
  * 用戶為問題設置延遲時間
  */
 public void put(long time, Runnable task) {
  //轉(zhuǎn)換成ns
  long nanoTime = TimeUnit.NANOSECONDS.convert(time, TimeUnit.MILLISECONDS);
  //創(chuàng)建一個任務
  Task k = new Task(nanoTime, task);
  //將任務放在延遲的隊列中
  t.put(k);
 }

 /**
  * 結束訂單
  * @param task
  */
 public boolean endTask(Task<Runnable> task){
  return t.remove(task);
 }
}

使用方法