有没有办法在他们并行执行的时候，采取一套期货，并将其作为一个组加以封锁？

Question

我希望能够等待一组功能。我希望它们并行执行，但是阻塞，直到最后的未来完成。(我不希望它们像(do @(future-1) @(future-2))那样按顺序执行)

有点像

(declare long-running-fn-1)
(declare long-running-fn-2)

(let [results (wait-for-all
   (long-running-fn-1 ...)
   (long-running-fn-2 ...)]

     (println "result 1" (first results)
     (println "result 2" (second results))

Answer 1

期货被添加到用于send的线程池中。只要该池中有足够多的空闲线程(其大小将略大于您可用的CPU核数)，计算就立即开始。

(doall @(future ...) @(future ...))的问题是在第一个future被删除之后才创建第二个future。

下面是一个稍微修改过的代码版本，它定义了两个期货(开始计算)，然后再对它们进行处理；您将看到，这只需要5秒，而不是10秒：

(time
  (let [future-1 (future (Thread/sleep 5000))
        future-2 (future (Thread/sleep 5000))]
    [@future-1 @future-2]))

Answer 2

下面是另一个示例，演示并行执行+同步取消引用：

(letfn [(mk-fut [sleep-ms res]
          (future
            (Thread/sleep sleep-ms)
            (println "return" res "after" sleep-ms "ms")
            res))]
  (let [futures (mapv mk-fut
                      (repeatedly #(rand-int 2000))
                      (range 10))]
    (mapv deref futures)))

;; return 3 after 104 ms
;; return 8 after 278 ms
;; return 0 after 675 ms
;; return 6 after 899 ms
;; return 1 after 928 ms
;; return 2 after 1329 ms
;; return 9 after 1383 ms
;; return 4 after 1633 ms
;; return 5 after 1931 ms
;; return 7 after 1972 ms
;;=> [0 1 2 3 4 5 6 7 8 9]

(输出输出的顺序在不同的调用之间会有所不同，而生成的向量将是相同的)，您可以看到所有的期货都是并行运行的，而生成和取消引用的顺序是特定的。

Answer 3

使用pcalls或pvalues

test1.core=> (pcalls #(inc 1) #(dec 5))
(2 4)
test1.core=> (pvalues (inc 1) (dec 5))
(2 4)

在内部，它们使用pmap，它并行地执行函数，并在处理所有函数时返回延迟的结果序列。