可激活的间隔任务执行器

近来做项目，遇到一个很蛋疼的问题。以前早就遇到过，但是由于以前系统有变通的方法解决，也就没再弄这个事情。

什么问题呢 ？ 就是一般情况下，系统会执行以下有时间间隔的周期性任务（比如，每小时执行一次垃圾数据的清理工作），但是，遇到特殊情况还要临时激活任务，让任务临时执行一下（比如突发性垃圾数据猛增）。

对于带有时间间隔的周期性任务，写个执行器应该是一件很容易的事情。开启一个线程，每次执行完任务就sleep一个时间间隔，这样往复循环下去，就可以了。

基于上述思路，列举部分代码如下：

package houlei.support.util.task;

/**
 * 间隔执行的周期任务
 */
public interface DelayTask extends CycleTask{

	/**
	 * 调度任务的时间间隔
	 */
	long getDelay();
	
}

上述的是一个接口类，它有父接口，有execute方法，用于执行任务内容；有getDelay方法，用于获取执行任务的时间间隔。

package houlei.support.util.task;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import houlei.support.lang.ErrorHandler;

/**
 * 可激活的间隔任务执行器。只执行间隔执行的周期任务。
 * <p>主要执行间隔任务，当任务处于休眠期时，可通过调用{@link #active()}方法，唤醒执行器，激活当前任务。</p>
 */
public class ActivableDelayTaskWorker {

	private static final Logger LOG = LoggerFactory.getLogger(ActivableDelayTaskWorker.class);
	
	private ErrorHandler errorHandler = new ErrorHandler() {
		public void doHandler(Throwable throwable, String s) {
			LOG.error(s, throwable);
		}
	};
	
	private DelayTask delayTask;
	private Worker worker;
	private String name;
	private volatile boolean busy = false;
	
	/**
	 * 执行器线程
	 */
	private class Worker extends Thread{
		public Worker() {
			super(name);
		}
		private volatile boolean running = false;
		public void run(){
			LOG.info("线程["+Thread.currentThread().getName()+"]开始运行。");
			while(running){
				try {
					busy = true;
					delayTask.execute();
					busy = false;
					try {
						synchronized (worker) {
							worker.wait(delayTask.getDelay());
						}
					} catch (InterruptedException e) {
					}
				} catch (Throwable t) {
					errorHandler.doHandler(t, "任务["+name+"]在调用过程中出现异常。");
				}
			}
			LOG.info("线程["+Thread.currentThread().getName()+"]运行结束。");
		}
	}
	
	/**
	 * @param name 线程名称
	 * @param delayTask 周期任务的实例
	 */
	public ActivableDelayTaskWorker(String name, DelayTask delayTask) {
		if(name==null)throw new IllegalArgumentException("参数[name]不能为空");
		if(delayTask==null)throw new IllegalArgumentException("参数[delayTask]不能为空");
		this.name = name;this.delayTask = delayTask;
		worker = new Worker();
	}
	
	/**
	 * 唤醒执行器，激活当前任务。
	 */
	public void active(){
		if(busy)return;
		synchronized (worker) {
			worker.notify();
		}
	}
	
	/**
	 * 执行器的工作状况，是否处于任务调度阶段。
	 */
	public boolean isBusy() {
		return busy;
	}
	
	/**
	 * 开启调度线程
	 */
	public void startup(){
		if(!worker.running){
			worker.running = true;
			worker.start();
		}
	}
	
	/**
	 * 结束调度线程
	 */
	public void shutdown(){
		if(worker.running){
			worker.running = false;
			worker.interrupt();
			try {
				worker.join(5000);
			} catch (InterruptedException e) {
				errorHandler.doHandler(e, "任务["+name+"]无法在5秒内终止");
			}
		}
	}
	
	public void setErrorHandler(ErrorHandler errorHandler) {
		this.errorHandler = errorHandler;
	}
	
	public ErrorHandler getErrorHandler() {
		return errorHandler;
	}
	public DelayTask getDelayTask() {
		return delayTask;
	}
	public String getName() {
		return name;
	}
}

这个就是执行器类了。当然，这个代码的质量不算高，因为，一个线程只能执行一个任务；线程的大部分时间都是在等待周期的到来。

但是，功能还是实现了。某些特定场景还是必须要用到的。