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

Question

我有一个 ScheduledExecutorService 可以在 tomcat 应用程序中每 12 小时安排一个任务到运行。该任务调用 REST 端点并执行一些其他计算和 returns 结果。它在本地和测试服务器中工作得很好，但是，它运行只在实时服务器中出现一次，而且再也不会出现。所有异常都得到处理，任务不到 5 秒即可完成。我还检查了服务器中的所有属性，以确保时间属性不会被其他属性覆盖。为了在本地进行测试，我将延迟时间减少到每 10 分钟一次，这仍然显示相同的行为，因此我排除了超时问题。我看过其他类似的问题，但 none 似乎有助于解决这个问题。 , , ScheduledExecutorService only loops once, , ScheduledExecutorService - Ignore already running runnable, ScheduledExecutorService schedule issue, Timer vs. ScheduledExecutorService scheduling

下面是我的代码：

@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 版本对调度程序的行为或是否有任何原因可能会在实时环境中发生这种情况？

我创建了一个 REST 端点来使用 ScheduledFuture 和 ScheduledThreadPoolExecutor

中的属性监视幕后发生的事情

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
}

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

java文档说："If any execution of this task takes longer than its period, then subsequent executions may start late, but will not concurrently execute." 我假设这就是未安排下一个任务的原因。如果您能解释可能导致这种情况发生的原因，那就太好了

Answer 1

问题不在于实施，实施很好。经过多次调试，VM box 运行应用程序似乎出现了故障。多次重启并重新部署应用服务后，恢复正常。请参阅问题以了解调试应用程序时采取的步骤。

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

ScheduledExecutorService works in local & test server but only runs once in live server

java

scheduling

executorservice

runnable

scheduledexecutorservice