JAVA技巧(JOTM中定时器的源码分析)

在Jotm看到一个非常完整的定时器，贴出来备用；
包org . object web . jotm；
导入Java . util . vector；
/**
*
*计时器列表中的计时器倒计时
*/
类时钟扩展线程{
私有计时器管理器TMGR
public Clock(timer manager tmgr){
super(" JotmClock ")；
if(trace TM . JTA . is debugenabled()){
trace TM . JTA . debug("时钟构造函数")；
}
this . tmgr = tmgr；
}
public void run(){
tmgr . clock()；
}
}
/* *
* exam da提示:走出计时器列表中的过期计时器，如倒计时为负
*/
类batch扩展线程{

public Batch(timer manager tmgr){
super(" JotmBatch ")；
if(trace TM . JTA . is debugenabled()){
trace TM . JTA . debug("批处理构造函数")；
}
this . tmgr = tmgr；
}
public void run(){
tmgr . batch()；
}
}
/**
*包含两个定时器列表和两个线程，一个线程对定时器进行倒计时，另一个线程清除到期的定时器并执行定时器的监听器动作；
*/
public class timer manager {
//管理服务的线程。
私有静态批处理batchThread
私有静态时钟clockThread
//lists
/timer list
私有向量timer list = new vector()；
//过期定时器列表
私有向量过期列表= new vector()；
//单实例
私有静态计时器管理器unique = null
private static boolean shuttling down = false；
/**
*构造函数
*/
private timer manager(){
//为计时器启动线程
Batch thread = new Batch(this)；
batch thread . set daemon(true)；
batch thread . start()；
clockThread =新时钟(this)；
clock thread . set daemon(true)；
clock thread . start()；
}
/**
*这个时间管理器是一个单例类；
*/
public static timer manager getInstance(){
if(unique = = null)
unique = new timer manager()；
返回唯一的；
}
/停止时间管理器中的计时器；
public static void Stop(boolean force){
if(trace TM . JTA . isdebugenabled()){
trace TM . JTA . debug(" Stop timer manager ")；
}
timer manager tmgr = getInstance()；
shutting down = true；
while(clock thread . isa live()| | batch thread . isa live()){
try {
thread . sleep(100)；
} catch(interrupted exception e){
break；
}
}
if(trace TM . JTA . isdebugenabled()){
trace TM . JTA . debug(" timer manager已停止")；
}
}
public static void stop(){
stop(true)；
}
/**
*关闭时加速时钟x 1000
*更新列表中的所有定时器
*每个到期的定时器都放在一个特殊的到期定时器列表中
*它们将由批处理线程处理。
*/void clock(){
//无限循环
while(true){
try {
//线程休息一秒钟
thread.sleep(关闭？1:1000);// 1秒或1ms沈shuttling down
//thread . current thread()。睡眠(shuttingdown？1:1000);// 1秒或1ms沈shutting down
synchronized(timer list){
int found = 0；
boolean empty = true；
for(int I = 0；I < timer list . size()；i++){
timer event t =(timer event)timer list . element at(I)；
//如果没有活动定时器，那么定时器队列为空；
如果(！t . is stopped()){
empty = false；
}
/如果计时器超时
if (t.update() //从计时器队列中删除
timer list . removeelementart(I-)；
If(t . valid()){
/如果该定时器有定时器侦听器，则将该定时器添加到过期定时器
//如果不存在，则将其废除，并且不向
expiredList.addElement(t)添加队列；
找到了++；
//如果继续，继续将定时器再次添加到定时器队列
If(t . is permanent()& & shutting down){
t . restart()；
timer list . add element(t)；
}
}
}
//确保此局部变量中不再有对bean的引用。
t = null；
}
if(发现> 0){
//唤醒线程；
timer list . notify()；
} else {
if(empty & & shuttling down){
break；
}
}
}
} catch(interrupted exception e){
trace TM . JTA . error(" Timer interrupted ")；
}
}
synchronized(timer list){//通知批处理，以便函数可以返回。
timer list . notify()；
}
}
/**
*处理所有过期的计时器
*/
public void batch(){
while(！(shutting down & & timer list . isempty()& & expired list . isempty()){
timer event t；
synchronized(timer list){
while(expired list . isempty()){
if(shutting down)return；
try {
// Timer Timer线程:如果发现定时器超时，则唤醒执行定时器的线程执行监听器动作
Timer list . wait()；
} catch(Exception e){
trace TM . JTA . error("批处理中的异常: "，e)；
}
}
t =(time revent)expired list . element at(0)；
expired list . removeelementat(0)；
}
/执行操作；
t . process()；
}
}
/**
*在列表中添加新的计时器
* @param tel对象，当计时器到期时将通知该对象。
* @param timeout nb计时器过期前的秒数。
* @param arg info与计时器一起传递
* @param permanent如果计时器是永久的，则为true。
*/
public timer event add timer(timer event listener tel，long timeout，Object arg，boolean permanent){
timer event te = new timer event(tel，timeout，arg，permanent)；
synchronized(timer list){
timer list . add element(te)；
}
return te；
}
/**
*从列表中删除计时器。这样效率不是很高。
*更好的方法是timer event . unset()
* @ deprecated
*/
public void remove timer(timer event te){
synchronized(timer list){
timer list . remove element(te)；
}
}
}