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


398

是否可以为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);
    }
}

3
自定义线程池是什么意思?只有一个通用的ForkJoinPool,但是您始终可以创建自己的ForkJoinPool并向其提交请求。
edharned

7
提示:Java冠军Heinz Kabutz检验了同样的问题,但影响更大:普通fork连接池的死锁线程。见javaspecialists.eu/archive/Issue223.html
消除童工

Answers:


395

实际上有一个技巧,如何在特定的fork-join池中执行并行操作。如果您将它作为一个任务在fork-join池中执行,它将停留在该位置并且不使用公共池。

final int parallelism = 4;
ForkJoinPool forkJoinPool = null;
try {
    forkJoinPool = new ForkJoinPool(parallelism);
    final List<Integer> primes = forkJoinPool.submit(() ->
        // Parallel task here, for example
        IntStream.range(1, 1_000_000).parallel()
                .filter(PrimesPrint::isPrime)
                .boxed().collect(Collectors.toList())
    ).get();
    System.out.println(primes);
} catch (InterruptedException | ExecutionException e) {
    throw new RuntimeException(e);
} finally {
    if (forkJoinPool != null) {
        forkJoinPool.shutdown();
    }
}

该技巧基于ForkJoinTask.fork,它指定:“安排在当前任务正在运行的池中异步执行此任务,如果适用,或者如果不包含inForkJoinPool(),则使用ForkJoinPool.commonPool()”。


20
有关解决方案的详细信息,请参见
Lukas

3
但是,是否还指定了流使用ForkJoinPool还是实现细节?到文档的链接会很好。
Nicolai 2014年

6
@Lukas感谢您的摘录。我将添加该ForkJoinPool实例应该在shutdown()不再需要它的时候,以避免线程泄漏。(示例)
jck 2015年

5
请注意,Java 8中存在一个错误,即使任务正在自定义池实例上运行,但它们仍与共享池耦合:计算的大小与公共池而不是自定义池成比例。已在Java 10中修复:JDK-8190974
Terran

3
@terran这个问题也被固定为Java 8 bugs.openjdk.java.net/browse/JDK-8224620
Cutberto奥坎波

192

并行流使用默认值ForkJoinPool.commonPool默认情况下,该默认值与您拥有的处理器相比将少一个线程Runtime.getRuntime().availableProcessors()这是由返回的(这意味着并行流使用所有处理器,因为它们也使用主线程):

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

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

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

  • 将并行流执行提交到您自己的ForkJoinPool:yourFJP.submit(() -> stream.parallel().forEach(soSomething)).get();
  • 您可以使用系统属性来更改公共池的大小:System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "20")目标并行度为20个线程。但是,在向后移植补丁https://bugs.openjdk.java.net/browse/JDK-8190974之后,此方法不再起作用。

我的机器上有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 316 415 416 416 416

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

215215215215215215 216216216216216216216216216216216216216216216216216

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


30
commonPool实际上有一个小于availableProcessors,导致合计并行等于availableProcessors因为调用线程算作一个。
Marko Topolnik

2
提交回报ForkJoinTaskparallel() get()需要模仿的是:stream.parallel().forEach(soSomething)).get();
Grigory Kislin

5
我不相信这ForkJoinPool.submit(() -> stream.forEach(...))将对给定的进行我的Stream操作ForkJoinPool。我希望整个Stream-Action在ForJoinPool中作为一个动作执行,但是在内部仍在使用默认/通用的ForkJoinPool。您在哪里看到ForkJoinPool.submit()会按照您说的去做?
Frederic Leitenberger

@FredericLeitenberger您可能打算将您的评论放在Lukas的回答下面。
assylias

2
我现在看到stackoverflow.com/a/34930831/1520422很好地说明了它实际上如声明的那样工作。但是我还是不明白它是如何工作的。但我对“有效”感到满意。谢谢!
Frederic Leitenberger

39

除了在您自己的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
);

22

原始解决方案(设置ForkJoinPool公共并行性属性)不再起作用。查看原始答案中的链接,已将破坏此更新的更新回移植到Java8。如链接线程中所述,不能保证此解决方案永远有效。基于此,解决方案是在接受的答案中讨论了带有.get解决方案的forkjoinpool.submit。我认为反向端口也解决了该解决方案的不可靠性。

ForkJoinPool fjpool = new ForkJoinPool(10);
System.out.println("stream.parallel");
IntStream range = IntStream.range(0, 20);
fjpool.submit(() -> range.parallel()
        .forEach((int theInt) ->
        {
            try { Thread.sleep(100); } catch (Exception ignore) {}
            System.out.println(Thread.currentThread().getName() + " -- " + theInt);
        })).get();
System.out.println("list.parallelStream");
int [] array = IntStream.range(0, 20).toArray();
List<Integer> list = new ArrayList<>();
for (int theInt: array)
{
    list.add(theInt);
}
fjpool.submit(() -> list.parallelStream()
        .forEach((theInt) ->
        {
            try { Thread.sleep(100); } catch (Exception ignore) {}
            System.out.println(Thread.currentThread().getName() + " -- " + theInt);
        })).get();

ForkJoinPool.commonPool().getParallelism()在调试模式下,我看不到并行性的变化。
d-coder

谢谢。我做了一些测试/研究并更新了答案。看起来是一个更新更改了它,因为它可以在旧版本中使用。
Tod Casasent

为什么我总是得到这个:unreported exception InterruptedException; must be caught or declared to be thrown即使catch循环中有所有异常。
李小龙

洛基,我没有看到任何错误。了解Java版本和确切的行将有所帮助。“ InterruptedException”表明在您的版本中未正确关闭围绕睡眠的try / catch。
Tod Casasent

13

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

-Djava.util.concurrent.ForkJoinPool.common.parallelism=16

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


尽管它是一个全局设置,但它可以增加parallelStream
meadlai

这为我工作OpenJDK的版本“1.8.0_222”
阿巴斯

与上述相同的人,这在openjdk“ 11.0.6”上对我不起作用
Abbas

8

要测量实际使用的线程数,可以检查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

6
Thread.activeCount()不会告诉您哪些线程正在处理您的流。映射到Thread.currentThread()。getName(),然后映射到distinct()。然后您将意识到,并非池中的每个线程都会被使用...给处理增加延迟,池中的所有线程都将被利用。
keyoxy

7

到目前为止,我一直使用此问题的答案中所述的解决方案。现在,我想到了一个名为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。



1

我尝试如下自定义 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启动其子线程。


不允许其他执行人背后的可能原因是什么?
omjego,

@omjego这是一个很好的问题,也许您可​​以提出一个新问题,并提供更多详细信息以阐明您的想法;)
Hearen

1

去获取AbacusUtil。可以为并行流指定线程号。这是示例代码:

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

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


1

如果你不希望依靠应用漏洞,总有一种方式来实现通过实现自定义的收藏家一样,将结合mapcollect语义...你不会局限于ForkJoinPool:

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

幸运的是,它已经在此处完成,并且可以在Maven Central中使用:http//github.com/pivovarit/parallel-collectors

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


0

如果您不介意使用第三方库,则可以使用Cyclops-react在同一管道中混合顺序流和并行流,并提供自定义的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()));

或者,如果我们希望继续在顺序Stream中进行处理

 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);

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


0

如果您不需要自定义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   
}));

(要求此问题的重复问题已被锁定,请在这里告诉我)


-2

您可以尝试实现此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中选择线程(找不到合适的文档),因此请尝试使用其他threadNaming工厂,以确保是否选择了并行流中的线程从您提供的customThreadFactory中。4. commonThreadPool将不使用此customThreadFactory。


您能否提供一个可用的示例来演示如何使用您指定的内容?
J. Murray,
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.