java并行 java并行流指定线程池

转载

数据小香 2023-08-24 01:53:32

文章标签 java并行 java 8 thread pool System 自定义 java 文章分类 Java 后端开发

并发 - Java 8并行流中的自定义线程池

是否可以为Java 8并行流指定自定义线程池？我找不到任何地方。

想象一下，我有一个服务器应用程序，我想使用并行流。但是应用程序很大且是多线程的，因此我想将它划分为区分。我不想在另一个模块的应用程序块任务的一个模块中执行缓慢的任务。

如果我不能为不同的模块使用不同的线程池，这意味着我无法在大多数现实情况下安全地使用并行流。

请尝试以下示例。在单独的线程中执行一些CPU密集型任务。这些任务利用并行流。第一个任务被破坏，因此每个步骤需要1秒(通过线程休眠模拟)。问题是其他线程卡住并等待损坏的任务完成。这是一个人为的例子，但想象一下servlet应用程序和有人向共享fork连接池提交长时间运行的任务。

public class ParallelTest {
public static void main(String[] args) throws InterruptedException {
ExecutorService es = Executors.newCachedThreadPool();
es.execute(() -> runTask(1000)); //incorrect task
es.execute(() -> runTask(0));
es.execute(() -> runTask(0));
es.execute(() -> runTask(0));
es.execute(() -> runTask(0));
es.execute(() -> runTask(0));
es.shutdown();
es.awaitTermination(60, TimeUnit.SECONDS);
}
private static void runTask(int delay) {
range(1, 1_000_000).parallel().filter(ParallelTest::isPrime).peek(i -> Utils.sleep(delay)).max()
.ifPresent(max -> System.out.println(Thread.currentThread() + " " + max));
}
public static boolean isPrime(long n) {
return n > 1 && rangeClosed(2, (long) sqrt(n)).noneMatch(divisor -> n % divisor == 0);
}
}

11个解决方案

317 votes

实际上有一个技巧如何在特定的fork-join池中执行并行操作。如果将其作为fork-join池中的任务执行，它将保留在那里并且不使用公共任务。

ForkJoinPool forkJoinPool = new ForkJoinPool(2);
forkJoinPool.submit(() ->
//parallel task here, for example
IntStream.range(1, 1_000_000).parallel().filter(PrimesPrint::isPrime).collect(toList())
).get();

诀窍是基于ForkJoinTask.fork，它指定：“安排在当前任务运行的池中异步执行此任务(如果适用)，或者如果不是inForkJoinPool()则使用ForkJoinPool.commonPool()”

Lukas answered 2019-02-08T11:07:13Z

160 votes

并行流使用默认值System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "20")，默认情况下，由于您拥有处理器，所以线程少一个，如Runtime.getRuntime().availableProcessors()所示(这意味着并行流使用所有处理器，因为它们也使用主线程)：

对于需要单独或自定义池的应用程序，可以使用给定的目标并行度级别构造ForkJoinPool; 默认情况下，等于可用处理器的数量。

这也意味着如果您同时启动嵌套并行流或多个并行流，它们将共享同一个池。优点：您永远不会使用超过默认值(可用处理器数量)。缺点：您可能无法为您启动的每个并行流分配“所有处理器”(如果您碰巧有多个)。 (显然你可以使用ManagedBlocker来规避它。)

要更改并行流的执行方式，您也可以

将并行流执行提交到您自己的ForkJoinPool：System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "20")或

您可以使用系统属性更改公共池的大小：System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "20")，以获得20个线程的目标并行度。

我的机器上有后者的例子有8个处理器。如果我运行以下程序：

long start = System.currentTimeMillis();
IntStream s = IntStream.range(0, 20);
//System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "20");
s.parallel().forEach(i -> {
try { Thread.sleep(100); } catch (Exception ignore) {}
System.out.print((System.currentTimeMillis() - start) + " ");

});

输出是：

215 216 216 216 216 216 216 216 315 316 316 316 316 316 316 316 415 416 416 416

因此，您可以看到并行流一次处理8个项目，即它使用8个线程。但是，如果我取消注释注释行，则输出为：

215 215 215 215 215 216 216 216 216 216 216 216 216 216 216 216 216 216 216 216 216

这次，并行流使用了20个线程，并且流中的所有20个元素已同时处理。

assylias answered 2019-02-08T11:08:50Z

32 votes

除了在您自己的forkJoinPool中触发并行计算的技巧之外，您还可以将该池传递给CompletableFuture.supplyAsync方法，如：

ForkJoinPool forkJoinPool = new ForkJoinPool(2);
CompletableFuture> primes = CompletableFuture.supplyAsync(() ->
//parallel task here, for example
range(1, 1_000_000).parallel().filter(PrimesPrint::isPrime).collect(toList()),
forkJoinPool
);
Mario Fusco answered 2019-02-08T11:09:15Z
16 votes

使用ForkJoinPool并提交并行流不能可靠地使用所有线程。如果你看一下(来自HashSet的并行流不并行运行)和这个(为什么并行流不使用ForkJoinPool的所有线程？)，你会看到推理。

简短版本：如果ForkJoinPool / submit不适合您，请使用

System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "10");

Tod Casasent answered 2019-02-08T11:09:47Z

7 votes

到目前为止，我使用了这个问题的答案中描述的解决方案。现在，我想出了一个名为Parallel Stream Support的小库：

ForkJoinPool pool = new ForkJoinPool(NR_OF_THREADS);
ParallelIntStreamSupport.range(1, 1_000_000, pool)
.filter(PrimesPrint::isPrime)
.collect(toList())

但正如@PabloMatiasGomez在评论中指出的那样，并行流的分裂机制存在缺陷，这在很大程度上取决于公共池的大小。请参阅来自HashSet的并行流不并行运行。

我使用此解决方案只是为不同类型的工作提供单独的池，但即使我不使用它，我也无法将公共池的大小设置为1。

Stefan Ferstl answered 2019-02-08T11:10:25Z

6 votes

要测量实际使用的线程数，可以查看.parallel()：

Runnable r = () -> IntStream
.range(-42, +42)
.parallel()
.map(i -> Thread.activeCount())
.max()
.ifPresent(System.out::println);
ForkJoinPool.commonPool().submit(r).join();
new ForkJoinPool(42).submit(r).join();
这可以在4核CPU上产生如下输出：
5 // common pool
23 // custom pool
没有.parallel()它给出：
3 // common pool
4 // custom pool
charlie answered 2019-02-08T11:11:05Z
1 votes

去获取AbacusUtil。可以为并行流指定线程数。以下是示例代码：

LongStream.range(4, 1_000_000).parallel(threadNum)...

披露：我是AbacusUtil的开发人员。

user_3380739 answered 2019-02-08T11:11:32Z

1 votes

注意：似乎在JDK 10中实现了一个修复，确保自定义线程池使用预期的线程数。

自定义ForkJoinPool中的并行流执行应遵循并行性[https://bugs.openjdk.java.net/browse/JDK-8190974]

Scott Langley answered 2019-02-08T11:12:04Z

0 votes

如果您不介意使用第三方库，使用cyclops-react，您可以在同一个管道中混合顺序和并行Streams并提供自定义ForkJoinPools。例如

ReactiveSeq.range(1, 1_000_000)
.foldParallel(new ForkJoinPool(10),
s->s.filter(i->true)
.peek(i->System.out.println("Thread " + Thread.currentThread().getId()))
.max(Comparator.naturalOrder()));

或者，如果我们希望在顺序流中继续处理

ReactiveSeq.range(1, 1_000_000)
.parallel(new ForkJoinPool(10),
s->s.filter(i->true)
.peek(i->System.out.println("Thread " + Thread.currentThread().getId())))
.map(this::processSequentially)
.forEach(System.out::println);

[披露我是独眼巨人的主要开发者 - 反应]

John McClean answered 2019-02-08T11:12:43Z

0 votes

我按照以下方式尝试了自定义ForkJoinPool来调整池大小：

private static Set ThreadNameSet = new HashSet<>();
private static Callable getSum() {
List aList = LongStream.rangeClosed(0, 10_000_000).boxed().collect(Collectors.toList());
return () -> aList.parallelStream()
.peek((i) -> {
String threadName = Thread.currentThread().getName();
ThreadNameSet.add(threadName);
})
.reduce(0L, Long::sum);
}
private static void testForkJoinPool() {
final int parallelism = 10;
ForkJoinPool forkJoinPool = null;
Long result = 0L;
try {
forkJoinPool = new ForkJoinPool(parallelism);
result = forkJoinPool.submit(getSum()).get(); //this makes it an overall blocking call
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
} finally {
if (forkJoinPool != null) {
forkJoinPool.shutdown(); //always remember to shutdown the pool
}
}
out.println(result);
out.println(ThreadNameSet);
}

这是输出说池正在使用比默认4更多的线程。

50000005000000
[ForkJoinPool-1-worker-8, ForkJoinPool-1-worker-9, ForkJoinPool-1-worker-6, ForkJoinPool-1-worker-11, ForkJoinPool-1-worker-10, ForkJoinPool-1-worker-1, ForkJoinPool-1-worker-15, ForkJoinPool-1-worker-13, ForkJoinPool-1-worker-4, ForkJoinPool-1-worker-2]
但实际上有一个怪人，当我尝试使用parallelStream达到相同的结果时如下：
BlockingDeque blockingDeque = new LinkedBlockingDeque(1000);
ThreadPoolExecutor fixedSizePool = new ThreadPoolExecutor(10, 20, 60, TimeUnit.SECONDS, blockingDeque, new MyThreadFactory("my-thread"));

但我失败了。

它只会在新线程中启动parallelStream，然后其他所有内容都是相同的，这再次证明parallelStream将使用ForkJoinPool来启动其子线程。

Hearen answered 2019-02-08T11:13:36Z

0 votes

如果您不需要自定义ThreadPool但是您想要限制并发任务的数量，则可以使用：

List paths = List.of("/path/file1.csv", "/path/file2.csv", "/path/file3.csv").stream().map(e -> Paths.get(e)).collect(toList());
List> partitions = Lists.partition(paths, 4); // Guava method
partitions.forEach(group -> group.parallelStream().forEach(csvFilePath -> {
// do your processing
}));

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。