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

Question

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

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

Answer 1

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

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

对于简单的仅 Java 解决方案，请尝试 定时器API。

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

Answer 2

如果您的 Java 应用程序打算连续运行，那么您可以使用 Timer< /a> 安排执行的类

如果您的应用程序不会连续运行，那么其他答案是正确的。 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 适合这种类型的事情。 Spring 应用程序也很好地支持它。

Answer 5

编写 Windows 服务（或 Linux 系统的守护程序）

---

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

• 运行 Java应用程序作为 Windows 服务
• 将 Java 应用程序转换为 Windows 服务
• < a href="http://www.source-code.biz/snippets/java/7.htm" rel="nofollow noreferrer">如何在 Linux 上将 Java 程序作为守护进程（服务）运行
• < a href="http://www.jguru.com/faq/view.jsp?EID=472493" rel="nofollow noreferrer">如何在 Linux 上将 Java 程序作为守护进程运行？

Answer 6

只需使用java.util.concurrent，它有一个计划执行小部件。 您需要添加一个保护条件以防止过度运行，或者在当前执行的末尾添加下一个执行。