龙盟编程博客 | 无障碍搜索 | 云盘搜索神器
快速搜索
主页 > 软件开发 > JAVA开发 >

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

时间:2009-12-23 15:42来源:未知 作者:admin 点击:
分享到:
http://tailsherry.javaeye.com/blog/176152 熟悉编写JavaScript的人,都习惯在页面写入setTimeOut来实现web页面的定时监控或事务处理。但是如何在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等功能,可以留给大家扩展。
  

精彩图集

赞助商链接