当前位置：文江博客话题详情

Java 中等效的并行扩展

发布于 2024-07-25 15:24:35 字数 90 浏览 12 评论 0原文

我在 .Net 开发中使用并行扩展有一些经验，但我正在考虑在 Java 中做一些工作，这些工作将受益于易于使用的并行库。 JVM 是否提供任何与并行扩展类似的工具？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

如日中天 2024-08-01 15:24:35

您应该熟悉 java.util.concurrent 包。它具有简单而强大的并行编程原语，并以此为基础的高级库。此类库的一个示例是 Functional Java，它具有一个易于使用的并行编程模块。

例如，下面是使用 Function Java 编写的规范 MapReduce 示例。它计算一组文档中的单词数，假设文档是字符流：

public static long countWords(final List<Stream<Character>> documents,
                              final ParModule m)
{ return m.parFoldMap(documents,
                      new F<Stream<Character>, Long>()
                      { public Long f(final Stream<Character> document)
                        { return (long)fromStream(document).words().length(); }},
                      longAdditionMonoid)
          .claim(); }

要实例化 ParModule，您需要给它一个并行策略。您可以实施自己的策略，或使用提供的策略。这是使用 16 个线程的固定池的线程：

ExecutorService pool = newFixedThreadPool(16);
ParModule m = parModule(executorStrategy(pool));

对于上面的示例，您需要以下导入：

import fj.F;
import fj.data.Stream;
import fj.control.parallel.ParModule;
import static fj.control.parallel.ParModule.parModule;
import static fj.pre.Monoid.longAdditionMonoid;
import static fj.data.LazyString.fromStream;     
import static fj.control.parallel.Strategy.executorStrategy;
import static java.util.concurrent.Executors.newFixedThreadPool;
import java.util.concurrent.ExecutorService;

You should become familiar with the java.util.concurrent package. It has simple and robust primitives for parallel programming upon which to base higher-level libraries. One example of such a library is Functional Java, which has an easy-to-use module for parallel programming.

For example, here is the canonical MapReduce example written using Functional Java. It counts the number of words in a set of documents, assuming documents are Streams of characters:

public static long countWords(final List<Stream<Character>> documents,
                              final ParModule m)
{ return m.parFoldMap(documents,
                      new F<Stream<Character>, Long>()
                      { public Long f(final Stream<Character> document)
                        { return (long)fromStream(document).words().length(); }},
                      longAdditionMonoid)
          .claim(); }

To instantiate ParModule, you give it a parallel Strategy. You can implement your own Strategies, or use one that's supplied. Here's one that uses a fixed pool of 16 threads:

ExecutorService pool = newFixedThreadPool(16);
ParModule m = parModule(executorStrategy(pool));

You need the following imports for the example above:

import fj.F;
import fj.data.Stream;
import fj.control.parallel.ParModule;
import static fj.control.parallel.ParModule.parModule;
import static fj.pre.Monoid.longAdditionMonoid;
import static fj.data.LazyString.fromStream;     
import static fj.control.parallel.Strategy.executorStrategy;
import static java.util.concurrent.Executors.newFixedThreadPool;
import java.util.concurrent.ExecutorService;

回复收藏 0 原文