基于Java线程实现后台定时监控

　2008-06-23 20:43:33　来源：WEB开发网　　　

核心提示：http://tailsherry.javaeye.com/blog/176152熟悉编写JavaScript的人，都习惯在页面写入setTimeOut来实现web页面的定时监控或事务处理，基于Java线程实现后台定时监控，但是如何在Java服务端来实现这样一个监控机制呢？一般大家都会想到线程，但是一直以来，比如这里我

http://tailsherry.javaeye.com/blog/176152

熟悉编写JavaScript的人，都习惯在页面写入setTimeOut来实现web页面的定时监控或事务处理。但是如何在Java服务端来实现这样一个监控机制呢？一般大家都会想到线程。但是一直以来，都没有亲身动手实践过。趁着工作间隙，自己也搬出一段代码来，与大家一起分享线程编程的神奇魔力。

首先创建一个基本抽象类SchedThread，代码内容如下：

view plaincopy to clipboardPRint?
package com.test;　

/**
* 基于Java线程实现后台定时监控 <P> Created: Mar 26, 2008 10:08:43 </P><P>
* </P><H4>http://tailsherry.javaeye.com</H4>
* <P>
*　
* @author TailSherry
*/
public abstract class SchedThread　
{　
　 protected static final long NEVER = Long.MAX_VALUE;　

　 // 定义一个线程锁，保证当前只有一个工作在操作中　
　 private final Object lock = new Object();　

　 // 定义一个Thread变量　
　 private Thread thread;　

　 // 控制线程循环的开关　
　 private boolean active = true;　

　 // 定义一个毫秒级的时间变量，指示何时执行下一个操作　
　 private long nextTime;　

　 /**
　　 * 定义个一个抽象的方法用来获取下一个执行操作的时间，可使用NEVER
　　 */
　 protected abstract long getNextTime();　

　 /**
　　 * 定义一个抽象的方法，让子类来定义具体的工作过程
　　 */
　 protected abstract void executeWork();　

　 protected String getName()　
　 {　
　　　 return getClass().getName();　
　 }　

　 /**
　　 * 启动线程
　　 */
　 public void start()　
　 {　
　　　 thread = new Thread(new Runnable()　
　　　 {　
　　　　　 public void run()　
　　　　　 {　
　　　　　　　 runInternal();　
　　　　　 }　
　　　 }, getName());　
　　　 thread.start();　
　 }　

　 /**
　　 * 强迫停止线程，跳出for循环
　　 */
　 public void stop() throws InterruptedException　
　 {　
　　　 synchronized (lock)　
　　　 {　
　　　　　 active = false;　
　　　　　 lock.notify();　
　　　 }　
　　　 thread.join();　
　 }　

　 /**
　　 * 此方法可以在任何时候激活当前线程，让线程进入工作执行环节
　　 */
　 public void workAdded(long time)　
　 {　
　　　 synchronized (lock)　
　　　 {　
　　　　　 if (time < nextTime)　
　　　　　 {　
　　　　　　　 // 立刻激活线程工作继续运行　
　　　　　　　 lock.notify();　
　　　　　 }　
　　　 }　
　 }　

　 /**
　　 * 线程监测控制逻辑部分
　　 */
　 private void runInternal()　
　 {　
　　　 // 无限循环　
　　　 for (;;)　
　　　 {　
　　　　　 // 该过程忽略了所有的Exception，以保证线程不会因此而中断　
　　　　　 try
　　　　　 {　
　　　　　　　 synchronized (lock)　
　　　　　　　 {　
　　　　　　　　　 nextTime = getNextTime();　
　　　　　　　　　 // 获得时间区间，即要等待的时间段　
　　　　　　　　　 long interval = nextTime - System.currentTimeMillis();　
　　　　　　　　　 if (interval > 0)　
　　　　　　　　　 {　
　　　　　　　　　　　 try
　　　　　　　　　　　 {　
　　　　　　　　　　　　　 lock.wait(interval);　
　　　　　　　　　　　 }　
　　　　　　　　　　　 catch (InterruptedException e)　
　　　　　　　　　　　 {　
　　　　　　　　　　　　　 // 忽略此Exception　
　　　　　　　　　　　 }　
　　　　　　　　　 }　
　　　　　　　　　 // 如果active为false，强制中断　
　　　　　　　　　 if (!active)　
　　　　　　　　　 {　
　　　　　　　　　　　 break;　
　　　　　　　　　 }　
　　　　　　　 }　
　　　　　　　 // 执行具体的工作　
　　　　　　　 executeWork();　
　　　　　 }　
　　　　　 catch (Throwable t)　
　　　　　 {　
　　　　　　　 try
　　　　　　　 {　
　　　　　　　　　 Thread.sleep(10000);　
　　　　　　　 }　
　　　　　　　 catch (InterruptedException ie)　
　　　　　　　 {　
　　　　　　　　　 // 忽略此Exception　
　　　　　　　 }　
　　　　　 }　
　　　 }　
　 }　
}</P>

package com.test;

/**
* 基于Java线程实现后台定时监控 Created: Mar 26, 2008 10:08:43
* http://tailsherry.javaeye.com
*
*
* @author TailSherry
*/
public abstract class SchedThread
{
　 protected static final long NEVER = Long.MAX_VALUE;

　 // 定义一个线程锁，保证当前只有一个工作在操作中
　 private final Object lock = new Object();

　 // 定义一个Thread变量
　 private Thread thread;

　 // 控制线程循环的开关
　 private boolean active = true;

　 // 定义一个毫秒级的时间变量，指示何时执行下一个操作
　 private long nextTime;

　 /**
　　 * 定义个一个抽象的方法用来获取下一个执行操作的时间，可使用NEVER
　　 */
　 protected abstract long getNextTime();

　 /**
　　 * 定义一个抽象的方法，让子类来定义具体的工作过程
　　 */
　 protected abstract void executeWork();

　 protected String getName()
　 {
　　　 return getClass().getName();
　 }

　 /**
　　 * 启动线程
　　 */
　 public void start()
　 {
　　　 thread = new Thread(new Runnable()
　　　 {
　　　　　 public void run()
　　　　　 {
　　　　　　　 runInternal();
　　　　　 }
　　　 }, getName());
　　　 thread.start();
　 }

　 /**
　　 * 强迫停止线程，跳出for循环
　　 */
　 public void stop() throws InterruptedException
　 {
　　　 synchronized (lock)
　　　 {
　　　　　 active = false;
　　　　　 lock.notify();
　　　 }
　　　 thread.join();
　 }

　 /**
　　 * 此方法可以在任何时候激活当前线程，让线程进入工作执行环节
　　 */
　 public void workAdded(long time)
　 {
　　　 synchronized (lock)
　　　 {
　　　　　 if (time < nextTime)
　　　　　 {
　　　　　　　 // 立刻激活线程工作继续运行
　　　　　　　 lock.notify();
　　　　　 }
　　　 }
　 }

　 /**
　　 * 线程监测控制逻辑部分
　　 */
　 private void runInternal()
　 {
　　　 // 无限循环
　　　 for (;;)
　　　 {
　　　　　 // 该过程忽略了所有的Exception，以保证线程不会因此而中断
　　　　　 try
　　　　　 {
　　　　　　　 synchronized (lock)
　　　　　　　 {
　　　　　　　　　 nextTime = getNextTime();
　　　　　　　　　 // 获得时间区间，即要等待的时间段
　　　　　　　　　 long interval = nextTime - System.currentTimeMillis();
　　　　　　　　　 if (interval > 0)
　　　　　　　　　 {
　　　　　　　　　　　 try
　　　　　　　　　　　 {
　　　　　　　　　　　　　 lock.wait(interval);
　　　　　　　　　　　 }
　　　　　　　　　　　 catch (InterruptedException e)
　　　　　　　　　　　 {
　　　　　　　　　　　　　 // 忽略此Exception
　　　　　　　　　　　 }
　　　　　　　　　 }
　　　　　　　　　 // 如果active为false，强制中断
　　　　　　　　　 if (!active)
　　　　　　　　　 {
　　　　　　　　　　　 break;
　　　　　　　　　 }
　　　　　　　 }
　　　　　　　 // 执行具体的工作
　　　　　　　 executeWork();
　　　　　 }
　　　　　 catch (Throwable t)
　　　　　 {
　　　　　　　 try
　　　　　　　 {
　　　　　　　　　 Thread.sleep(10000);
　　　　　　　 }
　　　　　　　 catch (InterruptedException ie)
　　　　　　　 {
　　　　　　　　　 // 忽略此Exception
　　　　　　　 }
　　　　　 }
　　　 }
　 }
}

以上这个类非常关键，基本上已经实现了所有的控制逻辑，如此再扩展出一个实现类出来，比如这里我写了一个模拟实现类MyDataGenerator，大家可以参考一下：

Java代码 view plaincopy to clipboardprint?
　

view plaincopy to clipboardprint?
package com.test;　　
　　
public class MyDataGenerator extends SchedThread {　　
　 protected void executeWork() {　　
　　　 System.out.println("Execute work ...");　　
　 }　　
　　
　 protected long getNextTime() {　　
　　　 return System.currentTimeMillis() + 2000L;　　
　 }　　
　　
　 public static void main(String argv[]) {　　
　　　 MyDataGenerator generator = new MyDataGenerator();　　
　　　 generator.start();　　
　 }　　
}　

package com.test;　

public class MyDataGenerator extends SchedThread {　
　 protected void executeWork() {　
　　　 System.out.println("Execute work ...");　
　 }　

　 protected long getNextTime() {　
　　　 return System.currentTimeMillis() + 2000L;　
　 }　

　 public static void main(String argv[]) {　
　　　 MyDataGenerator generator = new MyDataGenerator();　
　　　 generator.start();　
　 }　
}
当然这里没有使用workAdded和stop等功能，可以留给大家扩展。