每小时运行一次 Java 代码

Question

我正在尝试编写一个简单的 Java 程序，该程序在分针为 20 时每小时运行一些代码。问题是我这样做的方式非常耗费 CPU。我熟悉 Quartz，但我正在寻找一个更简单的解决方案，有什么想法吗？

    boolean run = true;
    while(run){
        Calendar calendar = new GregorianCalendar();
        int minute = calendar.get(Calendar.MINUTE);
        if(minute == 20){
            //Do some Stuff             
        }
    }

Answer 1

一个简单的解决方案是使用 Executors 框架：

final ScheduledExecutorService s = Executors.newSingleThreadScheduledExecutor();
s.scheduleAtFixedRate(task, secondsToFirstOccurence, 60*60, TimeUnit.SECONDS);

并使用一些逻辑找出secondsToFirstOccurence。这可能涉及Calendar 实例，但使用 JodaTime 会更方便。

Answer 2

请注意，如果您的应用程序在托管环境（Web 或 ejb 容器）中运行，则不允许使用 Thread.sleep() 或任何其他与线程相关的操作，就此而言，请查看 @ 987654321@ 页。我对此提出警告，因为该问题被标记为 java-ee，因此“简单应用程序”可能并不那么简单——如果它在 Java EE 容器中运行，则需要注意其他事项。

如果您正在构建企业级应用程序，请忘记Thread.sleep()。找一个成熟的作业调度器，使用Quartz，它是一个开源且非常成熟和可靠的产品。或者使用Obsidian Scheduler，这是一个功能丰富的商业调度程序，比 Quartz 具有更多开箱即用的功能。

完全成熟的调度程序（但适合在容器内运行）的轻量级替代方案是使用Timer service。

Answer 3

您可能在两次通话之间寻找Thread.sleep()

Answer 4

查看java.util.Timer方法 scheduleAtFixedRate()。

Answer 5

我建议您从 java 程序中删除调度逻辑。
通过这样做，您可以只专注于您希望程序执行的操作，并将调度部分留给操作系统。
另外，例如，假设您决定在某个时候编写一个 c++ 程序来执行您的 java 代码所知道的操作，您不必在新程序中实现 cron 逻辑

话虽如此：

• 对于 Linux，您有 crontab
• 对于 Windows，您有 windows task schedule
• 对于 Mac，我不确定，但考虑到它是基于 UNIX 的 cron 应该存在。

Answer 6

将你的代码放入无限的while中并使用

Thread.sleep(3600000);

20点后开始执行

示例

while(1==1) {
    //Your code here
    try{
         Thread.sleep(3600000);
    }
    catch (Exception e) {}
}

Answer 7

为您希望每小时执行的方法安排一个 cron 作业，而不是阻止 sleep() 调用，使用一些调度框架，如 quartz

Answer 8

你应该看看ScheduledExecutorService

class BeeperControl {
private final ScheduledExecutorService scheduler = 
   Executors.newScheduledThreadPool(1);

public void beepForAnHour() {
    final Runnable beeper = new Runnable() {
            public void run() { System.out.println("beep"); }
        };
    final ScheduledFuture<?> beeperHandle = 
        scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS);
    scheduler.schedule(new Runnable() {
            public void run() { beeperHandle.cancel(true); }
        }, 60 * 60, SECONDS);
}
}

Answer 9

使用类似的东西

Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.HOUR_OF_DAY, 20);
calendar.set(Calendar.MINUTE, 20);
calendar.set(Calendar.SECOND, 0);
Date time = calendar.getTime();
Timer timer = new Timer();
timer.schedule(new SomeTask(), time);

然后重新安排

Answer 10

因此，正如许多其他答案所述，ScheduledExecutorService 绝对很棒。

如果您使用的是 Java EE 6 服务器，您可以通过 @Schedule 和 ScheduleExpression 获得一些乐趣

见Have an EJB schedule tasks with "crontab syntax"

Answer 11

1) 在第一次输入时计算下一个到期时间。

2) 使用java.util.Timer.schedule()

3) 重新安排每次运行。

代码

package tests;

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

public class App201210130040 {


private static Timer timer = new Timer(false);

public static void schedule() {
    Calendar due = Calendar.getInstance();
    due.set(Calendar.MINUTE, 20);
    if( due.before(Calendar.getInstance()) ) {
        due.add(Calendar.HOUR, 1);
    }

    System.out.println("Scheduled to " + due.getTime().toString());

    timer.schedule(new TimerTask() {

        @Override
        public void run() {

            System.out.println("due");

            schedule();
        }

    }, due.getTime());

}


public static void main(String[] args) {
    schedule();
}

}

Answer 12

另一个例子

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

public class TestHour {

    private static final int MINUNTE = 20;

    public static void main(String args[]) {
        while (true) {
            SimpleDateFormat bartDateFormat = new SimpleDateFormat("mm");
            Date date = new Date();
            int currentMin = new Integer(bartDateFormat.format(date))
                    .intValue();
            if (currentMin < MINUNTE) {
                sleepMinutes(MINUNTE - currentMin);
            } else if (currentMin > MINUNTE) {
                sleepMinutes(60 - currentMin + MINUNTE);
            } else {
                // DO SOMETHING EVERY HOUR
                System.out.println("come on do it!!!");
                sleepMinutes(60);
            }
        }
    }

    private static void sleepMinutes(int minutes) {
        try {
            System.out.println("Sleeping for " + minutes);
            Thread.sleep(minutes * 1000*60);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

Answer 13

今天学到的东西又是一个例子。

import java.util.Calendar;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class SchedulerExample2 implements Runnable{

    public static void main(String args[]) {

        Calendar due = Calendar.getInstance();
        due.set(Calendar.MILLISECOND, 0);
        due.set(Calendar.SECOND, 0);
        due.set(Calendar.MINUTE, 20);
        if (due.before(Calendar.getInstance())) {
            due.add(Calendar.HOUR, 1);
        }
        long milliSecondsToNextOcurrence =  due.getTimeInMillis() - new Date().getTime();
        final ScheduledExecutorService s = Executors.newSingleThreadScheduledExecutor();
        ShedulerExample task = new  ShedulerExample();
        s.scheduleAtFixedRate(task, milliSecondsToNextOcurrence, 60*60*1000, TimeUnit.MILLISECONDS);
    }

    @Override
    public void run() {
            System.out.println("hola->"+new Date());
    }   
}