一、了解DelayQueue
DelayQueue是什么？
DelayQueue是一個無界的BlockingQueue，用于放置實現了Delayed接口的對象，其中的對象只能在其到期時才能從隊列中取走。這種隊列是有序的，即隊頭對象的延遲到期時間最長。
注意：不能將null元素放置到這種隊列中。
DelayQueue能做什么？
在我們的業務中通常會有一些需求是這樣的：
- 淘寶訂單業務:下單之后如果三十分鐘之內沒有付款就自動取消訂單。
- 餓了嗎訂餐通知:下單成功后60s之后給用戶發送短信通知。
那么這類業務我們可以總結出一個特點:需要延遲工作。
由此的情況，就是我們的DelayQueue應用需求的產生。
二、怎么用DelayQueue來解決這類的問題
先聲明一個Delayed的對象
java" id="highlighter_842072">
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
import java.util.concurrent.Delayed;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicLong;/** * <p> * [任務調度系統] * <br> * [隊列中要執行的任務] * </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; }} |
再實現一個管理延遲任務的類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
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> * [任務調度系統] * <br> * [后臺守護線程不斷的執行檢測工作] * </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) { //修改問題的狀態 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; } } } /** * 創建一個最初為空的新 DelayQueue */ private DelayQueue<Task> t = new DelayQueue<>(); /** * 添加任務， * time 延遲時間 * task 任務 * 用戶為問題設置延遲時間 */ public void put(long time, Runnable task) { //轉換成ns long nanoTime = TimeUnit.NANOSECONDS.convert(time, TimeUnit.MILLISECONDS); //創建一個任務 Task k = new Task(nanoTime, task); //將任務放在延遲的隊列中 t.put(k); } /** * 結束訂單 * @param task */ public boolean endTask(Task<Runnable> task){ return t.remove(task); }} |
使用方法
- 在容器初始化的時候調用init方法.
- 實現一個runnable接口的類，調用TaskQueueDaemonThread的put方法傳入進去.
- 如果需要實現動態的取消任務的話，需要task任務的類重新hashcode方法，最好用業務限制hashcode的沖突發生.
總結
以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作能帶來一定的幫助，如果有疑問大家可以留言交流，謝謝大家對服務器之家的支持。
原文鏈接：http://www.jianshu.com/p/87fd5b9f5ffb
