Рассмотрим следующую ситуацию: мы используем параллельный поток Java 8 для выполнения параллельного цикла forEach, например,
IntStream.range(0,20).parallel().forEach(i -> { /* work done here */})
Количество параллельных потоков контролируется системным свойством "java.util.concurrent.ForkJoinPool.common.parallelism" и обычно равно количеству процессоров.
Теперь предположим, что нам нравится ограничивать количество параллельных исполнений для определенной части работы - например, потому что эта часть имеет интенсивность памяти и ограничение памяти подразумевает предел параллельных исполнений.
Очевидным и изящным способом ограничения параллельных исполнений является использование Семафора (предлагаемый здесь), например, следующий код кода ограничивает количество параллельных исполнений 5:
final Semaphore concurrentExecutions = new Semaphore(5);
IntStream.range(0,20).parallel().forEach(i -> {
concurrentExecutions.acquireUninterruptibly();
try {
/* WORK DONE HERE */
}
finally {
concurrentExecutions.release();
}
});
Это работает отлично!
Однако: использование любого другого параллельного потока внутри рабочего (в /* WORK DONE HERE */) может привести к тупику.
Для меня это неожиданное поведение.
Объяснение: Поскольку потоки Java используют пул ForkJoin, внутренний forEach является forking, и соединение, кажется, ждет навсегда. Однако это поведение по-прежнему является неожиданным. Обратите внимание, что параллельные потоки работают даже если вы установили "java.util.concurrent.ForkJoinPool.common.parallelism" в 1.
Обратите внимание, что он может быть не прозрачным, если есть внутренняя параллель для каждого.
Вопрос: Является ли это поведение в соответствии со спецификацией Java 8 (в этом случае это подразумевает, что использование Семафоров внутри рабочих параллельных потоков запрещено) или это ошибка?
Для удобства: Ниже приведен полный тестовый пример. Любые комбинации двух булевых операций, кроме "true, true", приводят к тупиковой ситуации.
Уточнение: Чтобы сделать это ясно, позвольте мне подчеркнуть один аспект: тупик не встречается в acquire семафора. Обратите внимание, что код состоит из
- приобрести семафор
- запустить код
- релиз семафора
и тупик происходит в 2. если этот фрагмент кода использует ДРУГОЙ параллельный поток. Затем тупик происходит внутри этого ДРУГОГО потока. Как следствие, кажется, что не разрешено использовать вложенные параллельные потоки и операции блокировки (например, семафор) вместе!
Обратите внимание, что документировано, что параллельные потоки используют ForkJoinPool и что ForkJoinPool и Семафор принадлежат одному и тому же пакету - java.util.concurrent (поэтому можно было бы ожидать, что они будут взаимодействовать красиво).
/*
* (c) Copyright Christian P. Fries, Germany. All rights reserved. Contact: [email protected]
*
* Created on 03.05.2014
*/
package net.finmath.experiments.concurrency;
import java.util.concurrent.Semaphore;
import java.util.stream.IntStream;
/**
* This is a test of Java 8 parallel streams.
*
* The idea behind this code is that the Semaphore concurrentExecutions
* should limit the parallel executions of the outer forEach (which is an
* <code>IntStream.range(0,numberOfTasks).parallel().forEach</code> (for example:
* the parallel executions of the outer forEach should be limited due to a
* memory constrain).
*
* Inside the execution block of the outer forEach we use another parallel stream
* to create an inner forEach. The number of concurrent
* executions of the inner forEach is not limited by us (it is however limited by a
* system property "java.util.concurrent.ForkJoinPool.common.parallelism").
*
* Problem: If the semaphore is used AND the inner forEach is active, then
* the execution will be DEADLOCKED.
*
* Note: A practical application is the implementation of the parallel
* LevenbergMarquardt optimizer in
* {@link http://finmath.net/java/finmath-lib/apidocs/net/finmath/optimizer/LevenbergMarquardt.html}
* In one application the number of tasks in the outer and inner loop is very large (>1000)
* and due to memory limitation the outer loop should be limited to a small (5) number
* of concurrent executions.
*
* @author Christian Fries
*/
public class ForkJoinPoolTest {
public static void main(String[] args) {
// Any combination of the booleans works, except (true,true)
final boolean isUseSemaphore = true;
final boolean isUseInnerStream = true;
final int numberOfTasksInOuterLoop = 20; // In real applications this can be a large number (e.g. > 1000).
final int numberOfTasksInInnerLoop = 100; // In real applications this can be a large number (e.g. > 1000).
final int concurrentExecusionsLimitInOuterLoop = 5;
final int concurrentExecutionsLimitForStreams = 10;
final Semaphore concurrentExecutions = new Semaphore(concurrentExecusionsLimitInOuterLoop);
System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism",Integer.toString(concurrentExecutionsLimitForStreams));
System.out.println("java.util.concurrent.ForkJoinPool.common.parallelism = " + System.getProperty("java.util.concurrent.ForkJoinPool.common.parallelism"));
IntStream.range(0,numberOfTasksInOuterLoop).parallel().forEach(i -> {
if(isUseSemaphore) {
concurrentExecutions.acquireUninterruptibly();
}
try {
System.out.println(i + "\t" + concurrentExecutions.availablePermits() + "\t" + Thread.currentThread());
if(isUseInnerStream) {
runCodeWhichUsesParallelStream(numberOfTasksInInnerLoop);
}
else {
try {
Thread.sleep(10*numberOfTasksInInnerLoop);
} catch (Exception e) {
}
}
}
finally {
if(isUseSemaphore) {
concurrentExecutions.release();
}
}
});
System.out.println("D O N E");
}
/**
* Runs code in a parallel forEach using streams.
*
* @param numberOfTasksInInnerLoop Number of tasks to execute.
*/
private static void runCodeWhichUsesParallelStream(int numberOfTasksInInnerLoop) {
IntStream.range(0,numberOfTasksInInnerLoop).parallel().forEach(j -> {
try {
Thread.sleep(10);
} catch (Exception e) {
}
});
}
}