对于应该永远运行的任务的 Java 执行器最佳实践

Question

我正在开发一个 Java 项目，其中需要异步运行多个任务。我相信 Executor 是我做到这一点的最佳方式，所以我正在熟悉它。 （是的，学习是有报酬的！）但是，我不清楚完成我想做的事情的最佳方法是什么。

为了便于讨论，假设我正在运行两个任务。两者都不会终止，并且都应该在应用程序的生命周期内运行。我正在尝试编写一个主包装类，以便：

• 如果任一任务抛出异常，包装器将捕获它并重新启动该任务。
• 如果任一任务运行完成，包装器将注意到并重新启动该任务。

现在，应该注意的是，这两个任务的实现都将把 run() 中的代码包装在一个永远不会运行完成的无限循环中，并使用一个应该处理所有运行时异常的 try/catch 块而不破坏循环。我正在尝试增加另一层确定性；如果我或跟随我的人做了一些愚蠢的事情，破坏了这些保护措施并停止了任务，则应用程序需要做出适当的反应。

是否有比我更有经验的人推荐的解决这个问题的最佳实践？

FWIW，我已经启动了这个测试类：

public class ExecTest {

   private static ExecutorService executor = null;
   private static Future results1 = null;
   private static Future results2 = null;

   public static void main(String[] args) {
      executor = Executors.newFixedThreadPool(2);
      while(true) {
         try {
            checkTasks();
            Thread.sleep(1000);
         }
         catch (Exception e) {
            System.err.println("Caught exception: " + e.getMessage());
         }
      }
   }

   private static void checkTasks() throws Exception{
      if (results1 == null || results1.isDone() || results1.isCancelled()) {
         results1 = executor.submit(new Test1());
      }

      if (results2 == null || results2.isDone() || results2.isCancelled()) {
         results2 = executor.submit(new Test2());
      }
   }
}

class Test1 implements Runnable {
   public void run() {
      while(true) {
         System.out.println("I'm test class 1");
         try {Thread.sleep(1000);} catch (Exception e) {}
      }

   }
}

class Test2 implements Runnable {
   public void run() {
      while(true) {
         System.out.println("I'm test class 2");
         try {Thread.sleep(1000);} catch (Exception e) {}
      }
   }
}

它的行为符合我想要的方式，但我不知道是否有任何陷阱、效率低下或完全错误的头脑等待着让我惊讶。 （事实上​​，鉴于我对此不熟悉，如果其中没有任何错误/不可取的地方，我会感到震惊。）

欢迎任何见解。

Answer 1

我在之前的项目中也遇到过类似的情况，当我的代码在愤怒的客户面前崩溃后，我和我的伙伴们添加了两大安全措施：

1. 在无限循环中，也捕获错误，而不仅仅是异常。有时，意外的事情发生了，Java 会向您抛出错误，而不是异常。
2. 使用后退开关，这样如果出现问题且不可恢复，您就不会急于启动另一个循环来使情况升级。相反，您需要等到情况恢复正常后再重新开始。

例如，我们遇到过这样的情况：数据库出现故障，并且在循环期间抛出 SQLException。不幸的结果是代码再次执行循环，却再次遇到相同的异常，等等。日志显示我们每秒遇到相同的 SQLException 大约 300 次！ ...这种情况间歇性地发生了几次，偶尔 JVM 会暂停 5 秒左右，在此期间应用程序没有响应，直到最终抛出错误并且线程终止！

因此，我们实施了一种退避策略，大致如下面的代码所示，如​​果异常不可恢复（或者异常在几分钟内恢复），那么我们会等待更长的时间才能恢复操作。

class Test1 implements Runnable {
  public void run() {
    boolean backoff = false;
    while(true) {
      if (backoff) {
        Thread.sleep (TIME_FOR_LONGER_BREAK);
        backoff = false;
      }
      System.out.println("I'm test class 1");
      try {
        // do important stuff here, use database and other critical resources
      }
      catch (SqlException se) {
       // code to delay the next loop
       backoff = true;
      }
      catch (Exception e) {
      }
      catch (Throwable t) {
      }
    }
  }
}

如果您以这种方式实现任务，那么我认为使用 checkTasks() 方法创建第三个“看门狗”线程没有意义。此外，出于与我上面概述的相同原因，我会谨慎地与执行者再次启动任务。首先，您需要了解任务失败的原因以及环境是否处于稳定状态，再次运行任务会有用。

Answer 2

除了目击之外，我通常会针对 PMD 等静态分析工具运行 Java 代码和 FindBugs 查找更深层次的问题。

特别是对于这段代码，FindBugs 不喜欢 results1 和 results2 在惰性初始化中不是易失性的，并且 run() 方法可能会忽略异常，因为它们没有被显式处理。

一般来说，我对 Thread.sleep 用于并发测试，首选计时器或终止状态/条件。如果无法计算结果而引发异常，Callable 可能有助于在发生中断时返回某些内容。

有关一些最佳实践和更多值得深思的内容，请查看并发实践。

Answer 3

这个怎么样

Runnable task = () -> {
  try{
    // do the task steps here
  } catch (Exception e){
    Thread.sleep (TIME_FOR_LONGER_BREAK);
  }    
};
ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
executor.scheduleAtFixedRate(task,0, 0,TimeUnit.SECONDS);

Answer 4

您尝试过 Quartz 框架 吗？