ForkJoinPool 不正确的 invokeAll 方法行为 (java)

Question

ExecutorService 有 invokeAll 方法，文档如下：

执行给定的任务，返回持有其任务的 Futures 列表 全部完成或超时到期时的状态和结果，以两者为准 首先发生。 Future.isDone 对于返回的每个元素都是 true 列表。 返回后，未完成的任务将被取消。笔记 已完成的任务可以正常终止或通过 抛出异常。如果该方法的结果是未定义的 在此操作正在进行时给定的集合被修改

考虑以下代码：

public class Main {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        List<Callable<Integer>> tasks = Arrays.asList(
                Main::veryLongCalculations,
                Main::veryLongCalculations,
                Main::veryLongCalculations);
        try {
            List<Future<Integer>> resultTasks = executorService.invokeAll(tasks, 2, TimeUnit.SECONDS);
            for (Future<Integer> task: resultTasks) {
                System.out.println("is done: " + task.isDone() + ", canceled: " + task.isCancelled());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static Integer veryLongCalculations() {
        while (!Thread.currentThread().isInterrupted()) {
            //very long calculations
        }
        System.out.println("interrupted");
        return 0;
    }
}

如果我们运行此代码，屏幕上将显示以下输出：

interrupted
interrupted
interrupted
is done: true, canceled: true
is done: true, canceled: true
is done: true, canceled: true

任务显然运行时间超过了超时时间，因此被取消。任务状态已完成。一切都按预期进行。

但是如果我们使用 ForkJoinPool 作为 ExecutorService (ExecutorService executorService = Executors.newWorkStealingPool()) 那么输出将是这样的：

interrupted
interrupted
is done: true, canceled: true
is done: true, canceled: true
is done: false, canceled: false

其中一个任务永远不会被取消，这与文档相矛盾 但是如果我们将sdk从java17更改为java11，那么它就可以正常工作。 我开始理解，看到ForkJoinPool继承自AbstractExecutorService类，它实现了invokeAll方法。但在 java 17 中，该方法在 ForkJoinPool 本身中被重载。这是重载方法：

@Override
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                     long timeout, TimeUnit unit)
    throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    ArrayList<Future<T>> futures = new ArrayList<>(tasks.size());
    try {
        for (Callable<T> t : tasks) {
            ForkJoinTask<T> f =
                new ForkJoinTask.AdaptedInterruptibleCallable<T>(t);
            futures.add(f);
            externalSubmit(f);
        }
        long startTime = System.nanoTime(), ns = nanos;
        boolean timedOut = (ns < 0L);
        for (int i = futures.size() - 1; i >= 0; --i) {
            Future<T> f = futures.get(i);
            if (!f.isDone()) {
                if (timedOut)
                    ForkJoinTask.cancelIgnoringExceptions(f);
                else {
                    ((ForkJoinTask<T>)f).awaitPoolInvoke(this, ns);
                    if ((ns = nanos - (System.nanoTime() - startTime)) < 0L)
                        timedOut = true;
                }
            }
        }
        return futures;
    } catch (Throwable t) {
        for (Future<T> e : futures)
            ForkJoinTask.cancelIgnoringExceptions(e);
        throw t;
    }
}

在第一次迭代中，timedOut 变量将始终为 false，因此一个任务永远不会被取消。这是一个错误吗？还是有其他原因导致这种情况？这种行为显然与文档相反，文档规定所有任务都应具有已完成状态，并且如果超时到期则应取消。