Java 每月定时器

Question

我正在尝试创建一个将在每个月的同一天运行的计时器/计时器任务。我无法安排重复计时器，因为一个月的时间长度并不总是相同。

所以，这是我的解决方案：

public class MyTask extends TimerTask {
    public void run(){
        //do process file stuff

        if(scheduledExecutionTime() != 0){
            TimerHelper.restartMyTimer();
        }
    }
}

public class TimerHelper {
    public static HashTable timersTable = new HashTable();

    public static void restartMyTimer(){
        Calendar runDate = Calendar.getInstance();
        runDate.set(Calendar.DAY_OF_MONTH, 1);
        runDate.set(Calendar.HOUR_OF_DAY, 4);
        runDate.set(Calendar.MINUTE, 0);
        runDate.add(Calendar.MONTH, 1);//set to next month

        MyTask myTask = new MyTask();
        Timer myTimer = new Timer();

        myTimer.schedule(myTask, runDate.getTime());

        timersTable = new HashTable();//keeping a reference to the timer so we 
        timersTable.put("1", myTimer);//have the option to cancel it later
    }
}

我想我会遇到的问题是，因为第一个 TimerTask 创建了第二个 Timer，第一个 Timer 会因为创建了第二个 Timer 而被保留吗？在第一个计时器上的代码完成后，垃圾收集会处理该线程和对象吗？随着时间的推移，我不想建立一堆不做任何事情但又没有被删除的线程。也许我对线程和计时器的工作原理没有正确的理解...

只要我不必使用第三方 JAR，我就可以接受其他创建每月计时器的方法的建议。

谢谢！

Answer 1

只使用计划的计时器怎么样，当您完成当前计划的任务计划时，下一步：

 ScheduledExecutorService es = Executors.newSingleThreadScheduledExecutor();

 es.schedule(new MyTask(), numberOfDaysRemaining(), TimeUnit.DAYS);


class MyTask implements Runnable {
 public void run() {
  try {
   // do it
  } finally {
   es.schedule(new MyTask(), numberOfDaysRemaining(), TimeUnit.DAYS);
  }
 }
}

您可以使用 JodaTime 更容易地进行日期计算。

Answer 2

最简单的解决方案可能是使用 cron 或等效的方法来安排独立程序的执行...

Answer 3

Quartz 调度程序 库允许您根据 cron 作业表达式进行调度。

Answer 4

我认为您还可以创建一个线程并从 DelayQueue 来执行此操作。但它并不像 ScheduledExecutorService 那么容易。

Answer 5

为什么每次都需要重新创建Timer？计时器只是带有粘合代码的线程。取消它会导致该计时器上运行的其他任务终止。

最好使用以下内容：

MonthlyTimer extends Timer {
     public void execute(TimerTask task, Date date, int dayOfMonth) {
          this.schedule(new TimerTaskWithCallback(task, dayOfMonth, this), date);
     }

     void taskCallback(TimerTaskWithCallback task) {
          this.schedule(new TimerTaskWithCallback(task.getImpl()), nextDate(task.getDayOfMonth())); //next date could be used from Oscar's post.
     }
}

TimerTaskWithCallback 仅在原始任务执行后执行 MonthlyTimer.taskCallback。可以有“try { } catch {} finally {}”粘合代码。

Answer 6

如果您担心创建不需要的对象，您始终可以创建一个对象，该对象又创建/“销毁”所有引用，因此创建的对象可能会被GC。

最坏的情况是，一年内你会拥有 12 个不需要的物品，我认为这是可以忍受的。不过你的担心还是有道理的。

这是我在执行结束时遵循乔尔建议的时间表的尝试。请注意，当前的计时器已被新的计时器替换，因此计时器和计时器任务都可以被GC。

package monthly.schedule;

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

public class MonthlyTimer { 
    // What to do
    private final Runnable whatToDo;

    // when 
    private final int dayOfMonth;
    private final int hourOfDay;

    // The current timer
    private Timer current = new Timer();//to avoid NPE

    public void cancelCurrent() { 
        current.cancel();// cancel this execution;
        current.purge(); // removes the timertask so it can be gc'ed
    }

    // create a new instance
    public static MonthlyTimer schedule( Runnable runnable, int dayOfMonth, int hourOfDay ) { 
        return new MonthlyTimer( runnable, dayOfMonth, hourOfDay );
    }

    private MonthlyTimer(Runnable runnable, int day, int hour ) { 
        this.whatToDo = runnable;
        this.dayOfMonth = day;
        this.hourOfDay = hour;
        schedule();
    }
    // Schedules the task for execution on next month. 
    private void schedule() { 
        // Do you mean like this?
        cancelCurrent();
        current = new Timer(); // assigning a new instance
        // will allow the previous Timer to be gc'ed

        current.schedule( new TimerTask() { 
            public void run() { 
                try { 
                    whatToDo.run();
                } finally { 
                    schedule();// schedule for the next month
                }
            }
        } , nextDate() );           
    }
    // Do the next date stuff
    private Date nextDate() { 
        Calendar runDate = Calendar.getInstance();
        runDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
        runDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
        runDate.set(Calendar.MINUTE, 0);
        runDate.add(Calendar.MONTH, 1);//set to next month
        return runDate.getTime();
    }
}

class UseIt { 
    public static void main( String [] args ) { 
        int the1st = 1;
        int at16hrs = 16;

        MonthlyTimer t = MonthlyTimer.schedule( new Runnable() { 
            public void run() { 
                System.out.println( "Hola" );
            }}, the1st, at16hrs );

        // will print "Hola" every 1st at 16:00 hrs.
       // if needed you can cancel with: 
        t.cancelCurrent();

    }
}

Answer 7

我建议简单地使用 Quartz 并通过 Quartz 调度作业。 quartz-scheduler.org/docs/tutorials/crontrigger.html" rel="noreferrer">CronTrigger 允许您指定希望在每月的第一天执行作业，并让 Quartz处理时序逻辑。

这里是如何使用 CronTrigger 的进一步代码示例。

Quartz 是一个极其简单易用的库。