一、了解DelayQueue
DelayQueue是什么?
DelayQueue是一个无界的BlockingQueue,用于放置实现了Delayed接口的对象,其中的对象只能在其到期时才能从队列中取走。这种队列是有序的,即队头对象的延迟到期时间最长。
注意:不能将null元素放置到这种队列中。
DelayQueue能做什么?
在我们的业务中通常会有一些需求是这样的:
- 淘宝订单业务:下单之后如果三十分钟之内没有付款就自动取消订单。
- 饿了吗订餐通知:下单成功后60s之后给用户发送短信通知。
那么这类业务我们可以总结出一个特点:需要延迟工作。
由此的情况,就是我们的DelayQueue应用需求的产生。
二、怎么用DelayQueue来解决这类的问题
先声明一个Delayed的对象
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