java 调度器

import  java.util.Calendar;

import  java.util.concurrent.DelayQueue;

import  java.util.concurrent.Delayed;

import  java.util.concurrent.ExecutorService;

import  java.util.concurrent.Executors;

import  java.util.concurrent.TimeUnit;

 

public  class  DelayQueueTest {

 

     public  static  void  main(String[] args)  throws  InterruptedException {

 

         SchedulerManager manager =  new  SchedulerManager();

         manager.addJob( new  EveryMinuteDelay( new  MyJob()));

         manager.start();

 

         printCurrentTime();

         sleepMinutes( 3 );            // 休息 3 分钟后关掉

         manager.stop();      // 停止工作

         printCurrentTime();

     }

 

     private  static  void  sleepMinutes( long  minutes) {

         try  {

             TimeUnit.MINUTES.sleep(minutes);

         }  catch  (InterruptedException e) {

             e.printStackTrace();

         }

     }

 

     private  static  void  printCurrentTime() {

         System.out.printf( "Current: %tF %<tT%n" , System.currentTimeMillis());

     }

}

 

/**

  * <p>任务调度管理器</p>

  *

  * 2010-5-28 下午11:30:20

  */

class  SchedulerManager {

 

     private  ExecutorService executor;

     private  DelayQueue<JobDelayed> jobs;

     private  Scheduler scheduler;

 

     public  SchedulerManager() {

         this ( 1 );

     }

 

     /**

      * 根据线程池中线程数量构造调度管理器

      * @param threadPool

      */

     public  SchedulerManager( int  threadPool) {

         this .jobs =  new  DelayQueue<JobDelayed>();

         // 由于调度管理器需要占用一个线程，因此需要加 1

         this .executor = Executors.newFixedThreadPool(threadPool +  1 );

         this .scheduler =  new  Scheduler( this );

     }

 

     /**

      * <p>添加需要计划的任务</p>

      *

      * @param job

      */

     public  void  addJob(JobDelayed jobDelayed) {

         jobDelayed.nextTime();   // 计算下一次执行的时间

         jobs.put(jobDelayed);    // 添加到延迟队列中去

     }

 

     public  void  start() {

         scheduler.start();   // 启动任务调度器

     }

 

     public  void  stop() {

         scheduler.stop();   // 停止任务调度器

     }

 

     private  void  execute()  throws  InterruptedException {

         submit(take());

     }

 

     /**

      * <p>将任务提交给线程池去执行</p>

      *

      * @param task

      */

     private  void  submit(Runnable task) {

         executor.submit(task);

     }

 

     /**

      * <p>强制停止工作</p>

      */

     private  void  shutdown() {

         executor.shutdown();

     }

 

     /**

      * <p>获取到时间的任务，如果该任务下一次还需要执行，将该任务加回队列中去。</p>

      *

      * @return

      * @throws InterruptedException

      */

     private  JobDelayed take()  throws  InterruptedException {

         JobDelayed jobDelayed = jobs.take();

         if (jobDelayed.hasNext()) {

             addJob(jobDelayed);

         }

         return  jobDelayed;

     }

 

     /**

      * <p>调度器</p>

      * 2010-5-28 下午11:40:58

      */

     private  static  class  Scheduler  implements  Runnable {

 

         private  SchedulerManager manager;

         private  boolean  running =  false ;

 

         /**

          * 使用调度管理器构造

          * @param manager

          */

         public  Scheduler(SchedulerManager manager) {

             this .manager = manager;

         }

 

         /**

          * <p>启动该调度器</p>

          */

         public  void  start() {

             if (!running) {

                 manager.submit( this );

                 this .running =  true ;

             }

         }

 

         /**

          * 执行任务调度工作

          */

         @Override

         public  void  run() {

             while (running) {

                 try  {

                     manager.execute();

                 }  catch  (InterruptedException e) {

                     e.printStackTrace();

                 }

             }

         }

 

         /**

          * <p>强制停止该调度器</p>

          */

         public  void  stop() {

             manager.shutdown();

             running =  false ;

         }

     }

}

 

/**

  * <p>需要进行任务调度的工作内容</p>

  */

interface  Job {

     public  void  execute();

}

 

/**

  * <p>测试工作，输出当前时间</p>

  */

class  MyJob  implements  Job {

     public  void  execute() {

         System.out.printf( "JOB OUTPUT: %tF %<tT%n" , System.currentTimeMillis());

     }

}

 

/**

  * <p>需要进行调度工作的任务</p>

  */

interface  JobDelayed  extends  Delayed, Runnable {

 

     /**

      * <p>计算下一次执行的时间</p>

      */

     public  void  nextTime();

 

     /**

      * <p>下一次是否需要执行</p>

      */

     public  boolean  hasNext();

}

 

/**

  * <p>需要进行每分钟调度工作的任务</p>

  */

class  EveryMinuteDelay  implements  JobDelayed {

 

     private  long  nextTime;

     private  Job job;

 

     public  EveryMinuteDelay(Job job) {

         this .job = job;

     }

 

     public  void  nextTime() {

         Calendar c = Calendar.getInstance();

         c.set(Calendar.SECOND,  0 );

         c.set(Calendar.MILLISECOND,  0 );

         c.add(Calendar.MINUTE,  1 );

         this .nextTime = c.getTimeInMillis();   // 这个任务的 nextTime 为下一分钟

     }

 

     public  boolean  hasNext() {

         return  true ;    // 永远执行下去

     }

 

     @Override

     public  long  getDelay(TimeUnit unit) {

         return  nextTime - System.currentTimeMillis();    // 是否超时

     }

 

     @Override

     public  int  compareTo(Delayed o) {

         return  ( int )(o.getDelay(TimeUnit.MILLISECONDS) - getDelay(TimeUnit.MILLISECONDS));

     }

 

     @Override

     public  void  run() {

         job.execute();    // 执行任务

     }

 

     public  String toString() {

         return  String.format( "next: %tF %<tT" , nextTime);

     }

}