ScheduledExecutorService在本地和测试服务器中工作，但只在实时服务器中运行一次

Question

我有一个ScheduledExecutorService来安排一个任务在tomcat应用程序中每12小时运行一次。 该任务调用REST端点并执行一些其他计算并返回结果。 它在本地和测试服务器上工作得很好但是，它只运行一次，而不再在实时服务器中运行。 处理所有异常，完成任务的时间不到5秒。 我还检查了服务器中的所有属性，以确保时间属性不被其他属性覆盖。 为了在本地进行测试，我将延迟时间减少到每10分钟，这仍然显示相同的行为，所以我已经排除了问题的时间。 我看过其他类似的问题，但似乎没有人帮助解决这个问题。 ScheduledExecutorService仅运行一次 ， JAVA ScheduledExecutorService仅在调用Task <V>时运行一次 ， ScheduledExecutorService仅循环一次 ， ScheduledExecutorService - 任务停止运行 ， ScheduledExecutorService - 忽略已运行的runnable ， ScheduledExecutorService计划问题 ， Timer与ScheduledExecutorService计划

以下是我的代码：

@JsonIgnoreProperties(ignoreUnknown = true)
@JsonPropertyOrder({"name", "number"})
public class Company {

    @JsonProperty("name")
    private String name;
    @JsonProperty("number")
    private int number;

    public String getName() {
        return this.name;
    }

    public int getNumber() {
        return this.number;
    }

    @Override
    public String toString() {
        return new ToStringBuilder(Company.class)
            .append("name", this.name)
            .append("number", this.number).toString();
    }
}

public class CompanyDifference {

    private String name;
    private int difference;

    public CompanyDifference(String name, int difference) {
        this.name = name;
        this.difference = difference;
    }

    public String getName() {
        return this.name;
    }

    public int getDifference() {
        return this.difference;
    }

    @Override
    public String toString() {
        return new ToStringBuilder(CompanyDifference.class)
            .append("name", this.name)
            .append("difference", this.difference).toString();
    }
}

@Singleton
public class TaskRunner {
    public void doTask () {
        try {
            System.out.println("takes 2 sets of json data and returns the difference for each company");

            // takes 2 sets of json data and returns the difference for each company
            ObjectMapper mapper = new ObjectMapper();
            InputStream dataOne = Company.class.getResourceAsStream("/data.json");
            InputStream dataTwo = Company.class.getResourceAsStream("/data2.json");

            Company[] companyDataOne = mapper.readValue(dataOne, Company[].class);
            Company[] companyDataTwo = mapper.readValue(dataTwo, Company[].class);

            // Find the difference for each company and map company name to difference
            Map<String, Integer> mapDifferenceToCompany = new HashMap<>();

            for (int i = 0; i < companyDataOne.length; i++) {
                mapDifferenceToCompany.put(companyDataOne[i].getName(), Math.abs(companyDataOne[i].getNumber() - companyDataTwo[i].getNumber()));
            }

            mapDifferenceToCompany.forEach((key, value) -> System.out.println(String.valueOf(new CompanyDifference(key, value))));
        } catch (IOException e) {
            logger.info(String.format("Error: Failed to convert json to object with exception %s", e));
            throw new TaskSchedulerException("Failed to convert json to object with exception", e);
        } catch (Exception e) {
            logger.info(String.format("Error: Failed with exception %s", e));
            throw new TaskSchedulerException("Failed with exception", e);
        }
    }
}

@Singleton
public class TaskScheduler {

    private final Runnable runnable; 
    private final ScheduledExecutorService executorService;
    private static final Logger logger = LoggerFactory.getLogger(TaskScheduler.class);

    @Inject
    public TaskScheduler(TaskRunner taskRunner, int initialDelay, int period, String timeUnits) {
        this.executorService = Executors.newScheduledThreadPool(1);
        this.runnable = taskRunner::doTask;

        this.scheduledFuture = this.executorService.scheduleAtFixedRate(this.runnable, initialDelay, period,    
             TimeUnit.valueOf(timeUnits));
    }

    public static void main(String[] args) {
        TaskRunner taskRunner = new TaskRunner();
        new TaskScheduler(taskRunner, 1, 10, "MINUTES");
    }
}

在初始延迟1分钟后，任务在启动时运行一次，但不运行下一个计划任务。 它尝试运行计划任务但似乎没有完成任务，在检查实时服务器中的ScheduledThreadPoolExecutor属性后，我发现队列大小下降到0（当它应该始终为1时）意味着没有任务已经完成调度。

这表明，在初始任务完成后尝试运行计划任务时，它会删除计划任务，或者由于当前任务未完成而无法计划下一个任务。 由于在doTask方法中处理了所有异常，因此不会抛出任何错误或异常。 调度程序在本地和测试服务器中按预期工作，这使得难以复制方案。

想要查明实现是否缺少某些内容或可能导致它无法完成下一个计划任务的原因以及使队列大小降至0的原因。是否java版本对调度程序的行为有任何影响或者是否有任何影响为什么会在现场环境中发生这种情况？

我使用ScheduledFuture和ScheduledThreadPoolExecutor的属性创建了一个REST端点来监控底层的情况。

ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor) schedulerService;
this.queueSize = executor.getQueue().size();
this.remainingCapacity = executor.getQueue().remainingCapacity();
this.terminated = schedulerService.isTerminated();
this.shutdown = schedulerService.isShutdown();
this.taskCount = executor.getTaskCount();
this.activeTaskCount = executor.getActiveCount();
this.completedTaskCount = executor.getCompletedTaskCount();
this.keepAliveTime = executor.getKeepAliveTime(TimeUnit.SECONDS);
this.coreThreadTimeOut = executor.allowsCoreThreadTimeOut();
this.cancelled = scheduledFuture.isCancelled();
this.delay = scheduledFuture.getDelay(TimeUnit.MINUTES);

初始延迟后第一次运行的结果：由此，我们可以看到它完成了第一个任务，并且我从计算中得到了所需的结果。 taskCount（自启动以来的计划任务数）为2，表示已安排第二个任务，队列大小仍为1，这很好。

{
  "queueSize": 1,
  "remainingCapacity": 2147483647,
  "terminated": false,
  "shutdown": false,
  "taskCount": 2,
  "activeTaskCount": 0,
  "completedTaskCount": 1,
  "keepAliveTime": 0,
  "coreThreadTimeOut": false, 
  "periodic": true, 
  "cancelled": false
}

尝试第二次运行后的结果：这是卡住的地方。 completedTaskCount是2，但我不认为它实际上完成了任务，因为我没有从计算或任何日志中获得结果，表明它已经启动或完成了任务。 taskCount应该最多为3但它停留在2并且队列大小现在为0。

{
  "queueSize": 0,
  "remainingCapacity": 2147483647,
  "terminated": false,
  "shutdown": false,
  "taskCount": 2,
  "activeTaskCount": 0,
  "completedTaskCount": 2,
  "keepAliveTime": 0,
  "coreThreadTimeOut": false, 
  "periodic": true, 
  "cancelled": false
}

当我在本地和测试服务器上检查这些时，它工作正常，taskCount按预期上升，队列大小始终为1，这是预期的。 由此可以看出，由于某种原因，任务在第二次运行时卡住并且没有完成，因此它不会安排下一个任务。

javadoc说： “如果执行此任务的时间比其周期长，则后续执行可能会延迟，但不会同时执行。” 我假设这就是未安排下一个任务的原因。 如果你能解释可能导致这种情况发生的原因，那就太好了

Answer 1

问题不在于实施，实施是好的。 经过大量调试后，运行应用程序的VM盒似乎出现了问题。 重新启动多次并重新部署应用服务后，它恢复正常。 请参阅调试应用程序时所采取步骤的问题。