java 调度封装-阿里云开发者社区

java 调度封装

2013-06-12 1112

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介：

http://blog.csdn.net/gaojava/article/details/8608348

[java]view plaincopy 
   
 public class SchedulerService extends Service {   
     private static final int DEFAULT_POOL_SIZE = 2 * Runtime.getRuntime().availableProcessors();   
    
     private int poolSize;   
     private ScheduledExecutorService pool;   
    
     public int getPoolSize() {   
         return poolSize;   
     }   
    
     public void setPoolSize(int poolSize) {   
         if (poolSize < 0) {   
             logger.warning("pool size error,use default value:" + DEFAULT_POOL_SIZE);   
             poolSize = DEFAULT_POOL_SIZE;   
         }   
         this.poolSize = poolSize;   
     }   
    
     protected void initService() throws ServiceException {   
         pool = Executors.newScheduledThreadPool(poolSize);   
     }   
    
     protected void startService() throws ServiceException {   
         //   
     }   
    
     protected void stopService() throws ServiceException {   
         pool.shutdown();   
         try {   
             if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {   
                 pool.shutdownNow();   
                 if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {   
                     logger.severe("Pool did not terminate");   
                 }   
             }   
         } catch (InterruptedException e) {   
             pool.shutdownNow();   
             Thread.currentThread().interrupt();   
         }   
     }   
    
     ScheduledExecutorService getPool() {   
         return pool;   
     }   
    
     public Scheduler scheduleWithFixedDelay(Runnable task, long delay, long period, TimeUnit util) {   
         Scheduler scheduler = new Scheduler();   
         scheduler.setDelay(delay);   
         scheduler.setPeriod(period);   
         scheduler.setWorker(task);   
         scheduler.setService(this);   
         return scheduler;   
     }   
    
     public Scheduler schedule(Runnable task, long delay, TimeUnit util) {   
         Scheduler scheduler = new Scheduler();   
         scheduler.setDelay(delay);   
         scheduler.setPeriod(-1);   
         scheduler.setWorker(task);   
         scheduler.setService(this);   
         return scheduler;   
     }   
 }   

[java]view plaincopy 
   
 public class Scheduler {   
     private SchedulerService service;   
     private Runnable worker;   
     private long period = -1;   
     private long delay = 0;   
     private ScheduledFuture<?> task;   
    
     void setService(SchedulerService service) {   
         this.service = service;   
     }   
    
     void setWorker(Runnable worker) {   
         this.worker = worker;   
     }   
    
     void setPeriod(long period) {   
         this.period = period;   
     }   
    
     void setDelay(long delay) {   
         this.delay = delay;   
     }   
    
     public SchedulerService getService() {   
         return service;   
     }   
    
     public Runnable getWorker() {   
         return worker;   
     }   
    
     public ScheduledFuture<?> getTask() {   
         return task;   
     }   
    
     public void cancel() {   
         if (this.task != null   
                 && (!this.task.isCancelled() || !this.task.isDone())) {   
             this.task.cancel(true);   
         }   
     }   
    
     public long getDelay() {   
         return delay;   
     }   
    
     public long getPeriod() {   
         return period;   
     }   
    
     public boolean isRunning() {   
         return task != null && !task.isCancelled() && !task.isDone();   
     }   
    
     public synchronized void start() {   
         if (!isRunning()) {   
             if (service != null && worker != null) {   
                 if (this.period > 0) {   
                     task = service.getPool().scheduleWithFixedDelay(worker,   
                             this.delay, this.period, TimeUnit.MILLISECONDS);   
                 } else {   
                     task = service.getPool().schedule(worker, this.delay,   
                             TimeUnit.MILLISECONDS);   
                 }   
             }   
         }   
     }   
 }   

[java]view plaincopy 
   
 private Scheduler addSchedulerJob(final ITimeTask task,long delay ,final IPluginActivator activator) {   
     Scheduler timer = schedulerService.scheduleWithFixedDelay(new Runnable() {   
         public void run() {   
             try {   
                 if (activator.getState() == IPluginActivator.RUNNING) {   
                     task.excute();   
                 }   
             } catch (Throwable e) {   
                 logger.log(Level.SEVERE, "", e);   
             }   
         }   
     }, 0, delay, TimeUnit.MILLISECONDS);   
     return timer;   
 }   

java 调度封装

热门文章

最新文章

相关课程

相关电子书

相关实验场景