Multithreading 使用内置结构的并行编程有哪些好的库

我正在用这本书学习并行编程。本书使用了构建在C之上的

C*

语言

C*有它自己的结构，比如

forall

，这是一种超冷。它创建了我想要的任意多个并行进程。这里的进程是指同时执行的并行任务

例如

这将创建一个每个1000条记录的进程，如果有10000条记录，则将创建10000/1000=10个进程。每个流程将同时向艺术家发送电子邮件

我很好奇，是否有类似结构的语言可以在生产中使用

C*在学术上似乎是一个不错的编译器，但在生产上却毫无用处，而且它不是开源的，只能在

Windows OS

上运行

堡垒

for l <- seq(f.lines) do println l end
for l ← seq(f .lines) do println l end

---

对于lClojure，当然有所有的构造来完成您所寻找的<例如，code>pmap

，将延迟地将函数应用于并行的元素序列。它不会单独对元素进行分组，但可以很容易地与

partition all

函数结合，将原始序列划分为指定大小的分组<然后可以使用code>concat将结果合并回单个序列

例如，以下函数将以指定的组大小将函数映射到两个并行序列上：

(defn pmap-grouping [f group-size xs ys]
    (apply concat (pmap (partial mapv f)
                        (partition-all group-size xs)
                        (partition-all group-size ys))))

例如，

（pmap分组+2[1 2 3][4 5 6]）

返回

（5 7 9）

。请注意，我编写了

pmap grouping

以获取固定数量的序列以减少不熟悉的语法，但重新编写以处理任意数量的序列（任意数量1或更大）也同样简单：

请注意，使用

pmap

的此实现与您对所有

的描述之间存在一些差异。例如，
pmap
使用（最多）固定数量的线程。另一方面，这可能是您想要的，因为太多的线程将导致颠簸

即使Clojure没有
pmap
，也可以编写自己的
pmap
，直接使用线程。这肯定是更多的工作，但肯定是可能的。实际上，您真正需要的只是一种支持线程和高阶函数的语言。此外，函数与对象同构（即，可以使用对象实现函数，反之亦然）。因此，实际上任何支持线程的语言都可以工作

到目前为止，我们已经讨论了一种函数方法。如果您使用函数式语言，那么这种方法非常简洁，而且组合良好。然而，如果您还想获得语法抽象，Clojure宏在这方面非常出色

总之：


您可以使用线程在任何语言中进行并行编程，尽管您可能需要在某些语言中做更多的工作
函数式语言允许以简洁和可组合的方式表达并行计算
如果需要语法抽象，则必须使用具有所需语法内置项的语言，或者使用通过宏等支持语法扩展的语言（如Clojure）
您可能还想看看，对于一些并行计算，哪种内置机制很好：

(require '[clojure.core.reducers :as r])

(defn par-map [chunk-size f coll]
  (r/fold chunk-size
          (fn ([] []) ([c1 c2] (concat c1 c2)))
          conj
          (r/map f coll)))

(par-map 10 inc (vec (range 100)))

但是您应该记住，集合应该是可折叠的（例如，持久性向量或映射）
您可以查看以下内容：

这是一个很好的资源。
请参阅本页关于
pmap
的部分：@johnbakers选择
pmap
是为了回答一个非常普遍的问题。它并不意味着以任何方式表明它是在Clojure中进行并行计算的最佳方式。关键是，本着
pmap
的精神，函数基本上都是
forall
，除了语法糖和一些可能重要或不重要的实现细节（例如，惰性、分区等）。这是clojure中有多线程经验的人最好的答案。内置pmap不如减速机或其他替代品
(defn pmap-grouping [f group-size & cols]
    (apply concat (apply pmap (partial mapv f)
                              (map (partial partition-all group-size)
                                   cols))))

(require '[clojure.core.reducers :as r])

(defn par-map [chunk-size f coll]
  (r/fold chunk-size
          (fn ([] []) ([c1 c2] (concat c1 c2)))
          conj
          (r/map f coll)))

(par-map 10 inc (vec (range 100)))