Question

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

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

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

尝试以下示例。在单独的线程中执行一些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);
    }
}

Answer 1

实际上有一个技巧如何在特定的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（）”

Answer 2

并行流使用默认ForkJoinPool.commonPool Runtime.getRuntime().availableProcessors()，由yourFJP.submit(() -> stream.parallel().forEach(soSomething)).get();返回（这意味着并行流使用所有处理器，因为它们也使用主线程）：

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

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

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

将并行流执行提交给您自己的ForkJoinPool：System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "20")或
您可以使用系统属性更改公共池的大小：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) + " "); });，以获得20个线程的目标并行度。

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

{{1}}

输出结果为：

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

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

Answer 3

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

ForkJoinPool forkJoinPool = new ForkJoinPool(2);
CompletableFuture<List<Integer>> primes = CompletableFuture.supplyAsync(() ->
    //parallel task here, for example
    range(1, 1_000_000).parallel().filter(PrimesPrint::isPrime).collect(toList()), 
    forkJoinPool
);

Answer 4

使用ForkJoinPool并提交并行流并不能可靠地使用所有线程。如果你看这个（Parallel stream from a HashSet doesn't run in parallel）和这个（Why does the parallel stream not use all the threads of the ForkJoinPool?），你会看到推理。

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

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

Answer 5

要衡量实际使用的线程数，您可以查看Thread.activeCount()：

    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

Answer 6

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

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

但正如@PabloMatiasGomez在评论中指出的那样，并行流的分裂机制存在缺陷，这在很大程度上取决于公共池的大小。请参阅Parallel stream from a HashSet doesn't run in parallel。

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

Answer 7

我们可以使用以下属性更改默认并行度：

可以设置为使用更多并行性。

Answer 8

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

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

Answer 9

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

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

披露：我是AbacusUtil的开发者。

Answer 10

如果您不介意使用第三方库，使用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);

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

Answer 11

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

private static Set<String> ThreadNameSet = new HashSet<>();
private static Callable<Long> getSum() {
    List<Long> 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]

但实际上有一个怪人，当我尝试使用ThreadPoolExecutor获得相同的结果时如下：

BlockingDeque blockingDeque = new LinkedBlockingDeque(1000);
ThreadPoolExecutor fixedSizePool = new ThreadPoolExecutor(10, 20, 60, TimeUnit.SECONDS, blockingDeque, new MyThreadFactory("my-thread"));

但我失败了。

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

Answer 12

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

List<Path> paths = List.of("/path/file1.csv", "/path/file2.csv", "/path/file3.csv").stream().map(e -> Paths.get(e)).collect(toList());
List<List<Path>> partitions = Lists.partition(paths, 4); // Guava method

partitions.forEach(group -> group.parallelStream().forEach(csvFilePath -> {
       // do your processing   
}));

（询问此问题的重复问题已被锁定，请在这里告诉我）

Answer 13

如果您不希望依赖于实现黑客，总有一种方法可以通过实现将map和collect语义相结合的自定义收集器来实现……而您不会仅限ForkJoinPool：

list.stream()
  .collect(parallelToList(i -> fetchFromDb(i), executor))
  .join()

幸运的是，它已经在这里完成并可以在Maven Central上使用： http://github.com/pivovarit/parallel-collectors

免责声明：我写了它并对此负责。

Answer 14

您可以尝试实现此ForkJoinWorkerThreadFactory并将其注入到Fork-Join类中。

public ForkJoinPool(int parallelism,
                        ForkJoinWorkerThreadFactory factory,
                        UncaughtExceptionHandler handler,
                        boolean asyncMode) {
        this(checkParallelism(parallelism),
             checkFactory(factory),
             handler,
             asyncMode ? FIFO_QUEUE : LIFO_QUEUE,
             "ForkJoinPool-" + nextPoolId() + "-worker-");
        checkPermission();
    }

您可以使用Fork-Join池的此构造函数执行此操作。

注释：- 1.如果使用此方法，请考虑到基于新线程的实现，从JVM进行的调度将受到影响，这通常会将fork-join线程调度到不同的内核（视为计算线程）。 2.通过fork-join到线程的任务调度不会受到影响。 3.还没有真正弄清楚并行流如何选择线程从fork-join（找不到正确的文档），所以尝试使用其他线程命名工厂以确保是否有线程从customThreadFactory中选择并行流提供。 4. commonThreadPool不会使用此customThreadFactory。

Answer 15

这是我以编程方式设置上面提到的最大线程计数标志和剪断代码以验证参数是否合法的方式

System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "2");
Set<String> threadNames = Stream.iterate(0, n -> n + 1)
  .parallel()
  .limit(100000)
  .map(i -> Thread.currentThread().getName())
  .collect(Collectors.toSet());
System.out.println(threadNames);

// Output -> [ForkJoinPool.commonPool-worker-1, Test worker, ForkJoinPool.commonPool-worker-3]

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

15 个答案: