操作时避免在并行处理中死锁，可能会产生其他任务以在同一线程池上并行运行

如何解决操作时避免在并行处理中死锁，可能会产生其他任务以在同一线程池上并行运行

我正在用Java编写一些计算代码，我需要限制整个计算在特定数量的线程上运行（取决于可用的内核数和允许占用的内核数）。计算涉及适合并行处理的任务。因此，假设我为这样一种复杂的计算设置了以下设置。

class ComplexOpA implements Function<double[],double[]> {

    @Inject ExecutorService threadPool;

    /** 
     * Factory returns a Function<Double,Double> to call on each element 
     * of an input array 
     */
    @Inject ElementOperationFactory opFactory;

    double[] apply(double[] input) {

        int[] indices = int[input.length];
        for (int i = 0; i < input.length; i++)
            indices[i] = i;

        // Same operations need to be done on each element of `input`
        double[] output = new double[input.length];
        threadPool.invokeAll(createCallables(indices,i -> {
            double iInput = input[i];
            double iOutput = opFactory.createOperation().calculate(iInput);
            output[i] = iOutput;
        })
    }

    List<Callable<Void>> createCallables(
        int[] indices,Consumer<Integer> elementOperation){
        // Create list of Callable<Void> that can be passed to 
        // the executor service.
    }
}

假设Function提供的ElementOperationFactory不在尝试多线程执行，那么它将运行良好，没有任何问题。 但是，如果该元素函数本身的编写方式也使用相同的线程池来运行涉及并行处理的计算，则可能会出现死锁情况。例如，

class ElementOpA implements Function<Double,Double> {
    @Inject ExecutorService threadPool;
    public double apply(double input) {
        /* 
         * Assume there is a further complex operation here that the programmer
         * attempted to speed-up using multi-threading.
         */
        threadPool.invokeAll(...);
    }
}

在这种情况下，我们遇到了一个问题，即线程池中固定数量的线程可能全部在单个元素操作上受阻，以完成操作，但没有更多线程可用于元素中涉及的子任务-执行使它们无限期地阻塞。

有人可以建议一种避免这种潜在障碍的方法吗？

一些条件：

• 无法知道正在执行的任何操作在这些计算中需要花费多长时间。因此，使用超时是不可行的。
• 没有办法告诉程序员在哪个嵌套操作级别上，尝试将线程池用于并行处理。根据特定的用法，针对同一操作的几种可能的实现方式所执行的计算非常复杂。
• 只有一个公共线程池，任何尝试将其用于并行处理的操作始终可以访问和使用。