Question

我有一个应用程序需要做一件事，只有一件事，按计划进行，它将能够轻松计算下次需要运行的时间。从现在起，它可能不需要在几天或几个月内运行此任务，但可能每隔几毫秒就会在其他任何方面都处于活动状态。

我正在寻找一种简单的轻量级方法来安排一个任务运行。

Answer 1

在Unix上，查看系统工具cron或at。

在Windows上，系统设置中有一个作业调度程序。

对于简单的纯Java解决方案，请尝试Timer API。

对于更复杂的仅Java解决方案，请查看quartz。

Answer 2

如果您的Java应用程序要继续运行，那么您可以使用Timer类来安排执行

如果您的应用不会持续运行，那么其他答案都是正确的。 cron /任务调度程序是可行的方法。

Answer 3

好吧，如果您需要在特定时间运行应用程序，可以安排一个cron作业。或者，您可以编写一个简单的类，它将在特定时间安排自己。由于我不知道那里有任何图书馆（从来没有真正需要找一个），我很久以前就写了一个班，为自己安排任务。希望它有所帮助并且在球场：

import java.util.*;

public abstract class TimeMonitor extends Thread
    {
        protected double execution_time;
        protected boolean execute_at_startup;

        public TimeMonitor()
            {
                execute_at_startup = false;
            }

        public TimeMonitor(double time)
            {
                execution_time = time;
                execute_at_startup = false;
            }

        public void startTimer()
            {
                setPriority(Thread.MIN_PRIORITY);
                start();
            }

        public void setTime(double time)
            {
                execution_time = time;
            }

        public void executeAtStartup()
            {
                execute_at_startup = true;
            }

        public void run()
            {
                if (execute_at_startup)
                    doTimedAction();

                while (true)
                    {
                        long runtime = (long)(execution_time * 3600 * 1000);
                        long now     = getTime();
                        long sleep   = 0;

                        // Calculate how long to way until first run
                        if (runtime > now)
                            sleep = runtime - now;
                        else
                            sleep = 24 * 3600 * 1000 - now + runtime;

                        try
                            {
                                Thread.sleep(sleep);
                            }
                        catch (InterruptedException e)
                            {
                                logError("Wait thread has been interrupted.", e);
                                continue;
                            }

                        doTimedAction();
                    }
            }

        /**
         * Calculates number of milliseconds from start of the day.
         *
         * @return Number of milliseconds.
         */
        private long getTime()
            {
                Calendar cal = Calendar.getInstance();
                int hours   = cal.get(Calendar.HOUR_OF_DAY);
                int minutes = cal.get(Calendar.MINUTE);
                int seconds = cal.get(Calendar.SECOND);
                int millis  = cal.get(Calendar.MILLISECOND);

                return (hours * 3600 + minutes * 60 + seconds) * 1000 + millis;
            }

        private void doTimedAction()
            {
                try
                    {
                        performAction();
                    }
                catch (Throwable e)
                    {
                        logError("An error occured during timed execution.", e);
                    }
            }

        /**
         * This method will be called when an error or a warning occures.
         *
         * @param msg
         * @param e
         */
        protected void logError(String msg, Throwable e)
            {
                System.out.println(msg);
                e.printStackTrace();
            }

        /**
         * Action to be performed when scheduled time happens.
         */
        protected abstract void performAction();
    }

扩展使用它如下：

        TimeMonitor archiver = new TimeMonitor()
            {
                protected void performAction()
                    {
                        // Do the task
                    }
            };

        archiver.setTime(16.5); // Run at 4:30pm
        archiver.startTimer();

Answer 4

Quartz对这类事情有好处。这也是supported well in Spring个应用。

Answer 5

编写Windows服务（或Linux机器人的守护程序）

以下是一些可以帮助您入门的链接：

Answer 6

只需使用java.util.concurrent，它就有一个预定的执行小部件。您需要添加保护条件以防止过度运行，或者在当前结束时添加下一个执行。

我需要在Java中长时间（几天）睡觉

6 个答案: