如何正确关闭计划执行服务

Question

我仍在努力理解如何使用ScheduledExecutorService。我想要一个ScheduledExecutorService/ScheduledThreadPoolExecutor，它调度多个任务，并允许它们运行固定的时间。一旦不再调度任务，我就要关闭ScheduledThreadPoolExecutor。我试图通过编写一些测试来理解这是如何工作的。我尝试的第一件事是：

    @Test
    public void testExecutorService() throws Exception {
        ScheduledThreadPoolExecutor executorService = new ScheduledThreadPoolExecutor(1);
        executorService.setRemoveOnCancelPolicy(true);
        CountDownLatch latchOne = new CountDownLatch(5);
        CountDownLatch latchTwo = new CountDownLatch(10);

        ScheduledFuture<?> scheduledFutureOne = executorService.scheduleAtFixedRate(new MyRunnerOne(latchOne), 0, 1, TimeUnit.SECONDS);
        ScheduledFuture<?> scheduledFutureTwo = executorService.scheduleAtFixedRate(new MyRunnerTwo(latchTwo), 0, 2, TimeUnit.SECONDS);
        
        latchOne.await();
        scheduledFutureOne.cancel(false);
        latchTwo.await();
        scheduledFutureTwo.cancel(false);
        
        System.out.println("Shutting down service...");
        executorService.shutdown();
        Thread.sleep(100);
        assertTrue(executorService.isTerminated());
    }

    class MyRunnerOne implements Runnable
    {
        CountDownLatch latch;

        MyRunnerOne(CountDownLatch latch)
        {
            this.latch = latch;
        }

        @Override
        public void run()
        {
            System.out.println("Do Task One : " + latch.getCount());
            latch.countDown();
        }
    }


    class MyRunnerTwo implements Runnable
    {
        CountDownLatch latch;

        MyRunnerTwo(CountDownLatch latch)
        {
            this.latch = latch;
        }

        @Override
        public void run()
        {
            System.out.println("Do Task Two: " + latch.getCount());
            latch.countDown();
        }
    }

这工作得很好，我得到了预期的输出：

Do Task One : 5
Do Task Two: 10
Do Task One : 4
Do Task One : 3
Do Task Two: 9
Do Task One : 2
Do Task One : 1
Do Task Two: 8
Do Task Two: 7
Do Task Two: 6
Do Task Two: 5
Do Task Two: 4
Do Task Two: 3
Do Task Two: 2
Do Task Two: 1
Shutting down service...

然而，我认为这只是因为我在等待LatchTo之前等待latchOne，因为第一个任务花费的时间更少。如果我改变这个顺序，也就是。

        latchTwo.await();
        scheduledFutureTwo.cancel(false);
        latchOne.await();
        scheduledFutureOne.cancel(false);

任务一将被进一步执行，即使锁存已经达到零，因为它只在任务二之后被取消。有没有一种方法可以在锁存为零时立即执行某件事情（在这种情况下ne.cancel为false），并且一次执行多个锁存？

我也试图按照这个答案中描述的设置，它再次运行良好，但我不知道在哪里/如何关闭ExecutorService。设置类似，增加一个原子整数，直到达到所需调用的数量，然后我们取消未来。不过，这仍然不会关闭ExecutorService。

TLDR我希望使用单个ExecutorService来安排多个任务，每个任务用于固定数量的调用。应该允许ExecutorService处理任务的顺序是随机的。一旦不再计划任何任务，则应关闭ExecutorService。

谢谢你们的任何想法：）

Answer 1

如果您在执行器服务中重新安排任务本身，这将更容易做到：

ScheduledThreadPoolExecutor executorService = new ScheduledThreadPoolExecutor(1);
CountDownLatch latchOne = new CountDownLatch(1);
CountDownLatch latchTwo = new CountDownLatch(1);

executorService.submit(new MyRunnerOne(executorService, latchOne, 5));
executorService.submit(new MyRunnerTwo(executorService, latchTwo, 10));

latchTwo.await();
latchOne.await();

System.out.println("Shutting down service...");
executorService.shutdown();
executorService.awaitTermination(100, TimeUnit.SECONDS);
System.out.println("Terminated: " + executorService.isTerminated());

//...

class MyRunnerOne implements Runnable {
    private final ExecutorService service;
    private final CountDownLatch latch;
    private final int count;

    MyRunnerOne(ExecutorService service, CountDownLatch latch, int count) {
        this.service = service;
        this.latch = latch;
        this.count = count;
    }

    @Override
    public void run() {
        System.out.println("Do Task One : " + count);
    
        if (count > 1) {
            service.submit(new MyRunnerOne(service, latch, count - 1));
        } else {
            latch.countDown();
        }
    }
}

完整代码。