JOTM中定时器的源码分析

在Jotm中看到一个很齐全的定时器，贴出来以防备用；

1. package org.objectweb.jotm;
3. import java.util.Vector;
5. /**
6.  *
7.  *对计时器列表中的计时器进行倒计时
8.  */
9. class Clock extends Thread {
11.     private TimerManager tmgr;
13.     public Clock(TimerManager tmgr) {
14.         super("JotmClock");
15.         if (TraceTm.jta.isDebugEnabled()) {
16.             TraceTm.jta.debug("Clock constructor");
17.         }
19.         this.tmgr = tmgr;
20.     }
22.     public void run() {
23.         tmgr.clock();
24.     }
25. }
27. /**
28.  *
29.  *出去计时器列表中的过期计时器，如倒计时为负数
30.  */
31. class Batch extends Thread {
33.     private TimerManager tmgr;
35.     public Batch(TimerManager tmgr) {
36.         super("JotmBatch");
37.         if (TraceTm.jta.isDebugEnabled()) {
38.             TraceTm.jta.debug("Batch constructor");
39.         }
41.         this.tmgr = tmgr;
42.     }
44.     public void run() {
45.         tmgr.batch();
46.     }
47. }
49. /**
50.  *含有两个计时器列表，并且含有两个线程，一个线程进行计时器的倒计时，
51.  *一个线程移除过期计时器并且执行计时器的监听器动作；
52.  */
53. public class TimerManager {
55.     // threads managing the service.
56.     private static Batch batchThread;
57.     private static Clock clockThread;
59.     // lists
60.     //计时器列表
61.     private Vector timerList = new Vector();
62.     //过期计时器列表
63.     private Vector expiredList = new Vector();
64.     
65.     //单例
66.     private static TimerManager unique = null;
67.     private static boolean shuttingdown = false;
69.     /**
70.      * Constructor
71.      */
72.     private TimerManager() {
73.         // launch threads for timers
74.         batchThread = new Batch(this);
75.         batchThread.setDaemon(true);
76.         batchThread.start();
77.         clockThread = new Clock(this);
78.         clockThread.setDaemon(true);
79.         clockThread.start();
80.     }
82.     /**
83.      * 这个时间管理器是一个单例类；
84.      */
85.     public static TimerManager getInstance() {
86.         if (unique == null)
87.             unique = new TimerManager();
88.         return unique;
89.     }
91.     //停止时间管理器中的计时器；
92.     public static void stop(boolean force) {
93.         if (TraceTm.jta.isDebugEnabled()) {
94.             TraceTm.jta.debug("Stop TimerManager");
95.         }
97.         TimerManager tmgr = getInstance();
98.         shuttingdown = true;
99.         while (clockThread.isAlive() || batchThread.isAlive()) {
100.             try {
101.                 Thread.sleep(100);
102.             } catch (InterruptedException e) {
103.                 break;
104.             }
105.         }
106.         if (TraceTm.jta.isDebugEnabled()) {
107.             TraceTm.jta.debug("TimerManager has stopped");
108.         }
109.     }
111.     public static void stop() {
112.         stop(true);
113.     }
115.     /**
116.      * cney speed up the clock x1000 when shutting down
117.      * update all timers in the list
118.      * each timer expired is put in a special list of expired timers
119.      * they will be processed then by the Batch Thread.
120.      */
121.     public void clock() {
122.         //无限循环
123.         while (true) {
124.             try {
125.                 //线程休息一秒
126.                 Thread.sleep(shuttingdown?1:1000);  // 1 second or 1ms shen shuttingdown
127.                 // Thread.currentThread().sleep(shuttingdown?1:1000);    // 1 second or 1ms shen shuttingdown
128.                 synchronized(timerList) {
129.                     int found = 0;
130.                     boolean empty = true;
131.                     for (int i = 0; i < timerList.size(); i++) {
132.                         TimerEvent t = (TimerEvent) timerList.elementAt(i);
133.                         //如果没有活动的计时器，那么计时器队列为空；
134.                         if (!t.isStopped()) {
135.                             empty = false;
136.                         }
137.                         //如果计时器过期
138.                         if (t.update() <= 0) {
139.                             //从计时器队列中移除
140.                             timerList.removeElementAt(i--);
141.                             if (t.valid()) {
142.                                 //该计时器存在计时器监听器的话，把这个计时器加入过期计时器
143.                                 //如果不存在，则废除，哪个队列都不加入
144.                                 expiredList.addElement(t);
145.                                 found++;
146.                                 //如果持续的话，则继续把该计时器再次加入计时器队列中
147.                                 if (t.ispermanent() && !shuttingdown) {
148.                                     t.restart();
149.                                     timerList.addElement(t);
150.                                 }
151.                             }
152.                         }
153.                         // Be sure there is no more ref on bean in this local variable.
154.                         t = null;
155.                     }
156.                     if (found > 0) {
157.                         //唤醒线程；
158.                         timerList.notify();
159.                     } else {
160.                         if (empty && shuttingdown) {
161.                             break;
162.                         }
163.                     }
164.                 }
165.             } catch (InterruptedException e) {
166.                 TraceTm.jta.error("Timer interrupted");
167.             }
168.         }
169.         synchronized(timerList) { // notify batch so that function can return.
170.             timerList.notify();
171.         }
172.     }
174.     /**
175.      * process all expired timers
176.      */
177.     public void batch() {
179.         while (!(shuttingdown && timerList.isEmpty() && expiredList.isEmpty())) {
180.             TimerEvent t;
181.             synchronized(timerList) {
182.                 while (expiredList.isEmpty()) {
183.                     if (shuttingdown) return;
184.                     try {
185.                         //计时器计时线程让如果找到到期的计时器，那么就会唤醒执行该计时器的线程执行监听器动作
186.                         timerList.wait();
187.                     } catch (Exception e) {
188.                         TraceTm.jta.error("Exception in Batch: ", e);
189.                     }
190.                 }
191.                 t = (TimerEvent) expiredList.elementAt(0);
192.                 expiredList.removeElementAt(0);
193.             }
194.             //执行动作；
195.             t.process();
196.         }
197.     }
199.     /**
200.      * add a new timer in the list
201.      * @param tel Object that will be notified when the timer expire.
202.      * @param timeout nb of seconds before the timer expires.
203.      * @param arg info passed with the timer
204.      * @param permanent true if the timer is permanent.
205.      */
206.     public TimerEvent addTimer(TimerEventListener tel, long timeout, Object arg, boolean permanent) {
207.         TimerEvent te = new TimerEvent(tel, timeout, arg, permanent);
208.         synchronized(timerList) {
209.             timerList.addElement(te);
210.         }
211.         return te;
212.     }
214.     /**
215.      * remove a timer from the list. this is not very efficient.
216.      * A better way to do this is TimerEvent.unset()
217.      * @deprecated
218.      */
219.     public void removeTimer(TimerEvent te) {
220.         synchronized(timerList) {
221.             timerList.removeElement(te);
222.         }
223.     }
224. }