利用ArrayBlockingQueue实现大量计时任务计时

最近在做一个socket通讯的项目，项目中有个需求：根据客户端的请求记时，计时时间不定。

由于考虑到安全等因素，决定将所有客户端计时任务放在服务器端。最大同时计时任务需求为500个。

如果采用timer为每个任务计时，肯定不现实（服务器线程消耗严重）。出了这个考虑之外，还要考虑多线程线程安全的因素。

基于这些，我用到了ArrayBlockingQueue来实现。ArrayBlockingQueue是一个阻塞的同步队列，具体参考JDK文档。

主要思想是一个ArrayBlockingQueue来保存计时队列 一个ArrayBlockingQueue来保存计时完成要处理的队列。

一个线程不断扫描计时队列，检测时间是否到了，到了就添加到处理队列，由另外的线程来处理逻辑任务。

实现代码：

1. package test.client;
3. import java.util.concurrent.ArrayBlockingQueue;
5. /**
6.  *
7.  * @version 2008-11-22          
8.  */
9. public class TestMain {
11.     public static void main(String[] args) throws InterruptedException {
13.         //计时队列
14.         ArrayBlockingQueue<TimerTask> queue1 = new ArrayBlockingQueue<TimerTask>(1000, true);
16.         //处理队列
17.         ArrayBlockingQueue<TimerTask> queue2 = new ArrayBlockingQueue<TimerTask>(1000, true);
19.         //可以增加CheckThread DisposeThread线程进一步提高处理速度 降低延迟
20.         Thread t1 = new Thread(new AddThread(queue1));
21.         Thread t2 = new Thread(new CheckThread(queue1, queue2));
22.         Thread t3 = new Thread(new DisposeThread(queue2, new TestMain()));
24.         t1.start();
25.         t2.start();
26.         t3.start();
27.     }
29. }
31. /**
32.  * 此线程添加新的计时任务到计时队列
33.  */
34. class AddThread implements Runnable {
36.     private ArrayBlockingQueue<TimerTask> queue;
38.     public AddThread(ArrayBlockingQueue<TimerTask> queue) {
40.         this.queue = queue;
41.     }
43.     public void run() {
45.         while (true) {
46.             for (int i = 0; i < 500; i++) {
47.                 int time = 0;
48.                 if(i%3==0){
49.                     time = 60*1000;
50.                 }else if(i%3==1){
51.                     time = 2*60*1000;
52.                 }else if(i%3==2){
53.                     time = 5*60*1000;
54.                 }
55.                 TimerTask tt = new TimerTask(i, System.currentTimeMillis() + time);
56.                 try {
57.                     queue.put(tt);
58.                     //                  System.out.println("添加计时任务" + i);
59.                 } catch (InterruptedException e) {
60.                     e.printStackTrace();
61.                 }
62.             }
63.             try {
64.                 Thread.sleep(10 * 60 * 1000);
65.             } catch (InterruptedException e) {
66.                 e.printStackTrace();
67.             }
68.         }
69.     }
70. }
72. /**
73.  * 此线程扫描计时任务队列，检查计时是否完成
74.  */
75. class CheckThread implements Runnable {
77.     ArrayBlockingQueue<TimerTask> queue1;
78.     ArrayBlockingQueue<TimerTask> queue2;
80.     public CheckThread(ArrayBlockingQueue<TimerTask> queue1, ArrayBlockingQueue<TimerTask> queue2) {
82.         this.queue1 = queue1;
83.         this.queue2 = queue2;
84.     }
86.     public void run() {
88.         while (true) {
89.             for (int i = 0; i < 100; i++) {
90.                 TimerTask tt = null;
91.                 try {
92.                     tt = queue1.take();
93.                     //              System.out.println("检查计时任务" + tt.getRoleID());
94.                     if (tt.getEndTime() <= System.currentTimeMillis()) {
95.                         //                  System.out.println("添加执行任务" + tt.getRoleID());
96.                         queue2.put(tt);
97.                     } else {
98.                         queue1.put(tt);
99.                     }
100.                 } catch (InterruptedException e) {
101.                     e.printStackTrace();
102.                 }
103.             }
104.             try {
105.                 Thread.sleep(100);
106.             } catch (InterruptedException e) {
107.                 e.printStackTrace();
108.             }
109.         }
110.     }
111. }
113. /**
114.  * 此线程从计时任务完成的队列中不断取出计时任务并执行逻辑
115.  */
116. class DisposeThread implements Runnable {
118.     TestMain tm;
119.     
120.     ArrayBlockingQueue<TimerTask> queue2;
122.     public DisposeThread(ArrayBlockingQueue<TimerTask> queue2,TestMain tm) {
124.         this.queue2 = queue2;
125.         this.tm = tm;
126.     }
128.     public void run() {
130.         while (true) {
131.             TimerTask tt = null;
132.             try {
133.                 tt = queue2.take();
134.                 System.out.println("提取处理任务" + tt.getRoleID());
135.                 tm.test();
136.             } catch (InterruptedException e) {
137.                 e.printStackTrace();
138.             }
139.             if (tt != null) {
140.                 System.out.println(tt.getRoleID() + ":" + (tt.getEndTime() - System.currentTimeMillis()));
141.             }
142.         }
143.     }
144. }
146. /**
147.  * 计时任务
148.  */
149. class TimerTask {
151.     private Integer roleID;
153.     private Long endTime;
155.     public TimerTask(Integer roleID, Long endTime) {
157.         this.roleID = roleID;
158.         this.endTime = endTime;
159.     }
161.     public Integer getRoleID() {
163.         return roleID;
164.     }
166.     public void setRoleID(Integer roleID) {
168.         this.roleID = roleID;
169.     }
171.     public Long getEndTime() {
173.         return endTime;
174.     }
176.     public void setEndTime(Long endTime) {
178.         this.endTime = endTime;
179.     }
180. }