问题标签 [parallel-collections]

给定一个非常大的collection.parallel.mutable.ParHashMap实例（或任何其他并行集合），一旦找到给定的（例如 50 个）匹配数，如何中止过滤并行扫描？

尝试在线程安全的“外部”数据结构中累积中间匹配项或保留具有结果计数的外部 AtomicInteger 在 4 个内核上似乎比使用常规collection.mutable.HashMap并将单个内核固定为 100慢 2 到 3 倍%。

我知道Par* 集合上的find或存在确实会“在内部”中止。有没有一种方法可以概括这一点以找到多个结果？

这里的代码在 ParHashMap 上似乎仍然慢了 2 到 3 倍，大约有 79,000 个条目，并且还存在将超过 maxResults 结果填充到结果 CHM 中的问题（这可能是由于线程在incrementAndGet之后但在break之前被抢占允许其他线程添加更多元素）。更新：似乎速度变慢是由于工作线程在 counter.incrementAndGet() 上竞争，这当然违背了整个并行扫描的目的:-(

我拿了一个List[Int]并想搜索一个并行x的值x * 10 > 500。如果列表包含任何 51 或更大的值，那么exists应该返回。true

这给出了结果：

我正在使用带有 Scala 2.9.1 的双核机器。

这里发生了什么？这是否按预期工作？为什么它不在找到第一个结果后立即向其他线程发送消息以中止任务？f如果是昂贵的计算，这可能会非常昂贵。

find似乎以类似的方式工作，搜索更多的值，即使文档说“元素可能不一定是迭代顺序中的第一个这样的元素”和“选择是不确定的”。

在集合的映射中查找结果的习惯用法是这样的：

其中list是 a List[A]，f是 a A => B，并且p是 a B => Boolean。

是否可以view与并行集合一起使用？我问是因为我得到了一些非常奇怪的结果：

因此，对于家庭作业，我应该使用应该导致 pi 的函数的简单集成来使用几种线程机制。该实现应该处理超过 5000 亿的间隔。我当前的实现在 2GB 的堆大小上处理最多约 5000 万个 for 循环。现在我的问题是为什么实现使用这么多内存？（我认为这是因为必须提前确定范围，这是真的吗？）我如何提高内存使用率？是否可以使用并行集合，或者我是否被迫使用线程池来处理这样的事情？

注意：我将通过以下实现获得充分的信任。这是为了我的求知欲和我在 scala 中变得更加流利的梦想。

在 Scala/Hadoop 系统中充分利用多核进行并行处理的更好方法是什么？

假设我需要处理 1 亿份文档。文档不是很大，但处理它们是计算密集型的。如果我有一个 Hadoop 集群，其中有 100 台机器，每台机器有 10 个内核，我可以：

A) 向每台机器发送 1000 个文档，让 Hadoop 在 10 个核心（或尽可能多的可用核心）上启动映射

或者

B) 向每台机器发送 1000 个文档（仍然使用 Hadoop）并使用 Scala 的并行集合来充分利用多核。（我会将所有文档放在一个并行集合中，然后调用map该集合）。换句话说，在集群级别使用 Hadoop 进行分发，并使用并行集合来管理对每台机器内核心的分发。

因此，我一直在为我正在处理的图形项目使用 Scala 中的并行集合，我已经定义了图形类的基础知识，它目前正在使用scala.collection.mutable.HashMap键Int和值的位置ListBuffer[Int]（邻接列表） . （编辑：这已更改为ArrayBuffer[Int]

几个月前我在 C++ 中做过类似的事情，使用std::vector<int, std::vector<int> >.

我现在要做的是在图中的所有顶点对之间运行一个度量，所以在 C++ 中我做了这样的事情：

我在 Scala 中做了同样的事情，并行化，（或试图）这样做：

C++ 版本显然是单线程的，Scala 版本.par因此使用并行集合并且在 8 个内核（同一台机器）上是多线程的。然而，C++ 版本在大约 3 天内处理了 305,570 对，而 Scala 版本迄今为止仅在 17 小时内处理了 23,573 对。

假设我的数学计算正确，单线程 C++ 版本比 Scala 版本快大约 3 倍。Scala 真的比 C++ 慢得多，还是我完全误用了 Scala（我最近才开始使用 Scala 编程大约有 300 页）？

谢谢！-kstruct

编辑要使用 while 循环，我会做类似的事情吗？

如果你们的意思是对整个事情使用while循环，那么是否有相当于.par.foreachfor while的？

EDIT2等一下，那个代码甚至都不对——我的错。我将如何使用 while 循环并行化它？如果我有一些var i跟踪迭代，那么不是所有线程都在共享它i吗？

根据官方文档，有两种创建并行集合的选项：

1)

2)

现在，有什么区别？当我从简单的顺序集合转换它时是否存在任何性能损失？

如果您必须创建一个有点并行的集合（例如，数千个元素），您会怎么做，您会从头开始创建它还是转换它？

谢谢你们！

编辑：

正如@oxbow_lakes 所说，有一段文档专注于这个主题，但我正在尝试获得“经验丰富的建议”。我的意思是，例如，如果您必须从数据库中读取大量集合，您会怎么做。

假设我有一个有点大（大约几百万个项目）的字符串列表。运行这样的东西是个好主意：

或者在运行之前对列表进行分组是一个更好的主意...par.map(，如下所示：

更新：鉴于这someAction非常昂贵（与grouped,toList等相比）

我想要做的是开始使用 a 的一些实现，Map并通过迭代并行集合将数据累积到其中。密钥可以在线程之间“重叠”，因为密钥是概率生成的（与随机数生成有关）。

前任。线程 1 想要将 key = A value = 1 添加到映射中。如果它已经存在，则将 1 添加到现有值（因为值是 1） - 如果不存在，则创建映射。同时，另一个线程有 key = A 和 value = 2，并且想做同样的事情。

有没有办法在不创建整个Actor系统的情况下做到这一点？

ConcurrentHashMap来自 Java 的库似乎看起来很有趣，但是“弱一致性”迭代器让我担心跨线程更新映射的安全性。

从 Scala 2.8 开始，将 Java Collection 转换为 Scala 等价物的最简单方法是使用 JavaConversions。. 这些隐式定义返回包含的 Java 集合的包装器。

Scala 2.9 引入了并行集合，对集合的操作可以并行执行，然后再收集结果。这很容易实现，将现有集合转换为并行集合非常简单：

但是在使用 JavaConversions 从 Java 集合转换而来的集合上使用 'par' 存在问题。如Parallel Collection Conversions中所述，通过评估所有值并将它们添加到新的并行集合中，固有的顺序集合被“强制”到新的并行集合中：

其他集合，例如列表、队列或流，本质上是顺序的，因为元素必须一个接一个地访问。通过将元素复制到类似的并行集合中，这些集合被转换为它们的并行变体。例如，一个函数列表被转换成一个标准的不可变并行序列，它是一个并行向量。

当打算对原始 Java 集合进行延迟评估时，这会导致问题。例如，如果只返回一个 Java Iterable，然后转换为 Scala Iterable，则不能保证 Iterable 的内容是否会被急切地访问。那么应该如何从 Java 集合创建并行集合，而不需要维持评估每个元素的成本呢？我试图通过使用并行集合并行执行它们并希望“获取”提供的前 n 个结果来避免这种成本。

根据Parallel Collection Conversions有一系列的集合类型花费恒定的时间，但似乎没有办法保证这些类型可以由 JavaConversions 创建（例如，可以创建“Set”，但是那是一个'HashSet'？）。