简单任务执行程序

package times;
import java.text.SimpleDateFormat;
import java.util.Date;

//main方法
public class AlarmClock {
   private final Scheduler scheduler = new Scheduler();
private final SimpleDateFormat simpleDateFormat=new SimpleDateFormat("dd MMM yyyy HH:mm:ss.SSS");
private final int hourOfDay, minute, second;

public AlarmClock(int hourOfDay, int minute, int second)
{
this.hourOfDay=hourOfDay;
this.minute=minute;
this.second=second;
}

public void start()
{
scheduler.schedule(new SchedulerTask(){
   public void run()
   {
   soundAlarm();
   }
            private void soundAlarm() {
                System.out.println("Wake up! " +"It's " + simpleDateFormat.format(new Date()));
            }

}, new DailyIterator(hourOfDay, minute, second));
}

  public static void main(String [] args)
  {
  AlarmClock alarmClock =new AlarmClock(17,39,0);
  alarmClock.start();
  }
}

//时间迭代器
package times;

import java.util.Calendar;
import java.util.Date;

public class DailyIterator implements ScheduleIterator{

    @SuppressWarnings("unused")
private final int hourOfDay, minute, second;
    private final Calendar calendar = Calendar.getInstance();

    public DailyIterator(int hourOfDay, int minute, int second) {
        this(hourOfDay, minute, second, new Date());
    }

    public DailyIterator(int hourOfDay, int minute, int second, Date date) {
        this.hourOfDay = hourOfDay;
        this.minute = minute;
        this.second = second;
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, hourOfDay);
        calendar.set(Calendar.MINUTE, minute);
        calendar.set(Calendar.SECOND, second);
        calendar.set(Calendar.MILLISECOND, 0);
        if (!calendar.getTime().before(date)) {
            calendar.add(Calendar.DATE, -1);
        }
    }

    public Date next() {
        calendar.add(Calendar.DATE, 1);
        return calendar.getTime();
    }


}
//接口
package times;

import java.util.Date;

public interface ScheduleIterator {
public Date next();
}
//
package times;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Scheduler {

    class SchedulerTimerTask extends TimerTask {
        private SchedulerTask schedulerTask;
        private ScheduleIterator iterator;
        public SchedulerTimerTask(SchedulerTask schedulerTask,
                ScheduleIterator iterator) {
            this.schedulerTask = schedulerTask;
            this.iterator = iterator;
        }
        public void run() {
            schedulerTask.run();
            reschedule(schedulerTask, iterator);
        }
    }

    private final Timer timer = new Timer();

    public Scheduler() {
    }

    public void cancel() {
        timer.cancel();
    }

    public void schedule(SchedulerTask schedulerTask,
            ScheduleIterator iterator) {

        Date time = iterator.next();
        if (time == null) {
            schedulerTask.cancel();
        } else {
            synchronized(schedulerTask.lock) {
                if (schedulerTask.state != SchedulerTask.VIRGIN) {
                  throw new IllegalStateException("Task already scheduled " + "or cancelled");
                }
                schedulerTask.state = SchedulerTask.SCHEDULED;
                schedulerTask.timerTask =
                    new SchedulerTimerTask(schedulerTask, iterator);
                timer.schedule(schedulerTask.timerTask, time);
            }
        }
    }

    private void reschedule(SchedulerTask schedulerTask,
            ScheduleIterator iterator) {

        Date time = iterator.next();
        if (time == null) {
            schedulerTask.cancel();
        } else {
            synchronized(schedulerTask.lock) {
                if (schedulerTask.state != SchedulerTask.CANCELLED) {
                    schedulerTask.timerTask =
                        new SchedulerTimerTask(schedulerTask, iterator);
                    timer.schedule(schedulerTask.timerTask, time);
                }
            }
        }
    }

}
//
package times;

import java.util.TimerTask;

public abstract class SchedulerTask implements Runnable {

    final Object lock = new Object();

    int state = VIRGIN;
    static final int VIRGIN = 0;
    static final int SCHEDULED = 1;
    static final int CANCELLED = 2;

    TimerTask timerTask;

    protected SchedulerTask() {
    }

    public abstract void run();

    public boolean cancel() {
        synchronized(lock) {
            if (timerTask != null) {
                timerTask.cancel();
            }
            boolean result = (state == SCHEDULED);
            state = CANCELLED;
            return result;
        }
    }

    public long scheduledExecutionTime() {
        synchronized(lock) {
         return timerTask == null ? 0 : timerTask.scheduledExecutionTime();
        }
    }

}
该程序可以实现简单的自动跑任务程序，其实我们可以使用java中util类中的Timer和TimerTask实现定时任务，但是这个不够灵活，在使用夏令时就会出现任务执行时间上的偏差，在这里我们使用日历算法实现。虽然说执行任务的底层是JAVA虚拟机，会出现时间的差异，使用该算法至少可以避免一些问题，具体的自己也不是很清楚。在使用任务执行程序的时候，其实我们很难保证该任务是百分之一百的执行成功了，因此在做任务的时候还要做一些其他的策略，来捕捉没有成功执行的任务，根据具体的是业务需求来考虑是否再重复执行