Scala类似的QtConcurrent

Scala(或Java)的QtConcurrent有哪些类似物？即简化MapReduce,并行映射和foldl的实现.谢谢

您可以使用Scala Parallel Collections.它们目前是Scala nightly版本的一部分,将在Scala 2.9中发布.我们的想法是,常规集合中可用的大多数操作都是并行化的,因此可以以相同的方式使用并行集合.

目前,有一些可用的集合类型 - 并行范围,并行数组和并行哈希尝试.例如,您可以在并行数组上调用并行map和fold操作,如下所示:

scala> val pa = (0 until 10000).toArray.par
pa: scala.collection.parallel.mutable.ParArray[Int] = ParArray(0, 1, 2, 3, 4, 5, 6,...

scala> pa.map(_ + 1)
res0: scala.collection.parallel.mutable.ParArray[Int] = ParArray(1, 2, 3, 4, 5, 6, 7,...

scala> pa map { v => if (v % 2 == 0) v else -v }
res1: scala.collection.parallel.mutable.ParArray[Int] = ParArray(0, -1, 2, -3, 4, -5,...

scala> pa.fold(0) { _ + _ }
res2: Int = 49995000

还有其他并行收集操作.请注意,fold必须采用关联运算符 - 在上面的示例中,加法是关联的((A + B)+ C == A +(B + C)),即您可以按任何顺序添加数字的子序列,并且您将始终获得相同的金额(reduce有类似的合同).

另一件需要注意的事情是,同时调用传递给并行集合的闭包.如果它们有副作用,例如修改环境中的局部变量,则必须同步这些访问.例如,你可以这样做:

scala> var a = 0                                                                                                                                                                 
a: Int = 0                                                                                                                                                                       

scala> pa foreach { a += _ }                                                                                                                                                     

scala> a                                                                                                                                                                         
res1: Int = 49995000             

scala> a = 0
a: Int = 0

scala> pa foreach { a += _ }

scala> a
res7: Int = 49990086

并且每次都有不同的结果,因为并行foreach调用{ a += _ }.在上面的示例中,a应该使用锁或原子进行同步,保护.

但这个想法是使用内置的组合器来完成任务并倾向于功能编程,避免局部副作用,如上例所示.

您可能希望在其他答案中提供的链接中更多地了解其内部机制.

请参阅Scala Parallel Collections视频和论文" A Generic Parallel Collection Framework "

这表明:并行集合在当前的开发版本中,将作为Scala 2.9的一部分发布.请参阅此处的发布计划,Scala 2.9可从此处下载.