entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://clojuredocs.org/clojure.core/future|1|https://github.com/clojure/clojure/blob/clojure-1.9.0-alpha14/src/clj/clojure/core.clj#L6848|2|https://clojuredocs.org/clojure.core/future-call|3|https://clojuredocs.org/clojure.core/promise|4|https://clojuredocs.org/clojure.core/deliver|5|https://clojuredocs.org/clojure.core/deref|6|https://clojuredocs.org/clojure.core/realized_q|blocks|key|c27e4|text|Clojure的future+macro调用使用a+dedicated+executor+service的future-call函数。这意味着您无法控制执行顺序执行。|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|e7htk|另一方面，您可以使用promise而不是future对象和一个future线程来顺序地deliver结果。Promise的API与future提供的API类似。他们也有deref和realized?。|style|CODE|709fb|下面的代码示例在后台的新线程上顺序执行子任务，而函数的直接返回结果包含对计算值的承诺。|7p1aj|(defn+start-async-calc+[]
++(let+[f1+(promise)
++++++++f2+(promise)
++++++++f3+(promise)]
++++(future
++++++(deliver+f1+(task-1))
++++++(deliver+f2+(task-2))
++++++(deliver+f3+(task-3)))
++++{:task1+f1
+++++:task2+f2
+++++:task3+f3}))|code-block|syntax|javascript|bqrhk^0|8|C|0|O|S|1|1H|B|2|0|K|6|V|6|1T|6|A|7|3|17|7|4|2C|5|5|2I|9|6|0|0|0^^$0|$1|$2|3|4|5|6|$7|8]]|9|$2|3|4|5|6|$7|A]]|B|$2|3|4|5|6|$7|C]]|D|$2|3|4|5|6|$7|E]]|F|$2|3|4|5|6|$7|G]]|H|$2|3|4|5|6|$7|I]]|J|$2|3|4|5|6|$7|K]]]|L|@$M|N|O|P|2|Q|R|18|S|@]|T|@$U|19|V|1A|M|1B]|$U|1C|V|1D|M|1E]|$U|1F|V|1G|M|1H]]|6|$]]|$M|W|O|X|2|Q|R|1I|S|@$U|1J|V|1K|Y|Z]|$U|1L|V|1M|Y|Z]|$U|1N|V|1O|Y|Z]]|T|@$U|1P|V|1Q|M|1R]|$U|1S|V|1T|M|1U]|$U|1V|V|1W|M|1X]|$U|1Y|V|1Z|M|20]]|6|$]]|$M|10|O|11|2|Q|R|21|S|@]|T|@]|6|$]]|$M|12|O|13|2|14|R|22|S|@]|T|@]|6|$15|16]]|$M|17|O|-4|2|Q|R|23|S|@]|T|@]|6|$]]]]

Clojure's <a href="https://clojuredocs.org/clojure.core/future" rel="nofollow noreferrer">future macro</a> calls <a href="https://clojuredocs.org/clojure.core/future-call" rel="nofollow noreferrer">future-call</a> function which uses <a href="https://github.com/clojure/clojure/blob/clojure-1.9.0-alpha14/src/clj/clojure/core.clj#L6848" rel="nofollow noreferrer">a dedicated executor service</a>. This means that you have no control to enforce a sequential execution.

On the other hand you can use <a href="https://clojuredocs.org/clojure.core/promise" rel="nofollow noreferrer">promise</a> instead of <code>future</code> objects and one <code>future</code> thread to sequentially <a href="https://clojuredocs.org/clojure.core/deliver" rel="nofollow noreferrer">deliver</a> the results. Promise's API is similar to what <code>future</code>s provide. They have <a href="https://clojuredocs.org/clojure.core/deref" rel="nofollow noreferrer">deref</a> and <a href="https://clojuredocs.org/clojure.core/realized_q" rel="nofollow noreferrer">realized?</a> too.

The following code example has the subtasks executed sequentially on a new thread in the background while the immediately returned result of the function contains the promises to the computed values.

<pre><code>(defn start-async-calc []
 (let [f1 (promise)
 f2 (promise)
 f3 (promise)]
 (future
 (deliver f1 (task-1))
 (deliver f2 (task-2))
 (deliver f3 (task-3)))
 {:task1 f1
 :task2 f2
 :task3 f3}))
</code></pre>

entityMap|blocks|key|fvni0|text|如果您想对future调用进行序列化，您可以手动使用它，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5mmea|(do+@(future+1)
++++@(future+2)
++++@(future+3))|code-block|syntax|javascript|be3qb|它们仍然可能在不同的线程中调用，但在前一个线程完成之前不会调用下一个线程。这是由@+(或deref函数)保证的。这意味着在其中执行do表单的线程将在完成之前被前一个promise阻塞，然后产生下一个线程。|e1ggs|你可以像下面这样使用宏来美化它：|fr9p3|(defmacro+sequentialize+[&+futures]
++`(do+~@(map+#(list+`deref+%25)+futures)))

user>+(let+[a+(atom+1)]
++++++++(sequentialize
+++++++++(future+(swap!+a+#(*+10+%25)))
+++++++++(future+(swap!+a+#(%2B+20+%25)))
+++++++++(future+(swap!+a+#(-+%25))))
++++++++@a)
;;=>+-30|cep0c|这与手动do的作用完全相同。请注意，a原子的突变是有序的，即使某些线程运行的时间更长：|ajqbh|user>+(let+[a+(atom+1)]
++++++++(sequentialize
+++++++++(future+(Thread/sleep+100)
+++++++++++++++++(swap!+a+#(*+10+%25)))
+++++++++(future+(Thread/sleep+200)
+++++++++++++++++(swap!+a+#(%2B+20+%25)))
+++++++++(future+(swap!+a+#(-+%25))))
++++++++@a)
;;=>+-30|f869^0|5|6|0|0|14|1|18|5|1T|2|0|0|0|4|2|I|1|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|W|9|@$A|X|B|Y|C|D]]|E|@]|F|$]]|$2|G|4|H|6|I|8|Z|9|@]|E|@]|F|$J|K]]|$2|L|4|M|6|7|8|10|9|@$A|11|B|12|C|D]|$A|13|B|14|C|D]|$A|15|B|16|C|D]]|E|@]|F|$]]|$2|N|4|O|6|7|8|17|9|@]|E|@]|F|$]]|$2|P|4|Q|6|I|8|18|9|@]|E|@]|F|$J|K]]|$2|R|4|S|6|7|8|19|9|@$A|1A|B|1B|C|D]|$A|1C|B|1D|C|D]]|E|@]|F|$]]|$2|T|4|U|6|I|8|1E|9|@]|E|@]|F|$J|K]]|$2|V|4|-4|6|7|8|1F|9|@]|E|@]|F|$]]]]

if you want to sequentialize the calls to <code>future</code> you can use it manually like this:

<pre><code>(do @(future 1)
 @(future 2)
 @(future 3))
</code></pre>

they would still possibly called in different threads, but the next one won't be called until the previous has finished. This is guaranteed by the <code>@</code> (or <code>deref</code> function). This means that the thread in which you execute <code>do</code> form would be blocked with prev promise before it completes, and then spawn next one.

you can prettify it with macro like this:

<pre><code>(defmacro sequentialize [&amp; futures]
 `(do ~@(map #(list `deref %) futures)))

user&gt; (let [a (atom 1)]
 (sequentialize
 (future (swap! a #(* 10 %)))
 (future (swap! a #(+ 20 %)))
 (future (swap! a #(- %))))
 @a)
;;=&gt; -30
</code></pre>

this does exactly the same as manual <code>do</code>. Notice that mutations to <code>a</code> atom are in-order even if some threads run longer:

<pre><code>user&gt; (let [a (atom 1)]
 (sequentialize
 (future (Thread/sleep 100)
 (swap! a #(* 10 %)))
 (future (Thread/sleep 200)
 (swap! a #(+ 20 %)))
 (future (swap! a #(- %))))
 @a)
;;=&gt; -30
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://github.com/ztellman/manifold|1|http://aleph.io/codox/manifold/manifold.deferred.html#var-future-with|blocks|key|4n0rf|text|Manifold提供了一种创建未来with+specific+executor的方法。它不是核心Clojure库的一部分，但它仍然是一个高质量的库，并且可能是一个最佳选择，以防您需要比核心库提供更多的灵活性来处理未来(而不是求助于Java互操作)。|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|icq5^0|0|8|0|H|M|1|0^^$0|$1|$2|3|4|5|6|$7|8]]|9|$2|3|4|5|6|$7|A]]]|B|@$C|D|E|F|2|G|H|N|I|@]|J|@$K|O|L|P|C|Q]|$K|R|L|S|C|T]]|6|$]]|$C|M|E|-4|2|G|H|U|I|@]|J|@]|6|$]]]]

<a href="https://github.com/ztellman/manifold" rel="nofollow noreferrer">Manifold</a> provides a way to create future <a href="http://aleph.io/codox/manifold/manifold.deferred.html#var-future-with" rel="nofollow noreferrer">with specific executor</a>. It's not part of core Clojure lib, but it's still a high quality lib and probably a best option in case you need more flexibility dealing with futures than core lib provides (without resorting to Java interop).

entityMap|blocks|key|d6f91|text|除了前面提到的promises之外，您还可以使用delay。Promise的问题是，你可能会意外地无法交付它们，并且会造成future和delay无法实现的死锁情况。未来和延迟之间的区别仅仅是执行工作的线程。有了未来，工作是在后台完成的，而在延迟的情况下，工作是由试图破坏它的第一线程完成的。因此，如果未来比承诺更合适，你总是可以这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|9ba5u|(def+result-1+(delay+(long-calculation-1)))
(def+result-2+(delay+(long-calculation-2)))
(def+result-3+(delay+(long-calculation-3)))

(defn+run-calcs+[]
++@(future
+++++@result-1
+++++@result-2
+++++@result-3))|code-block|syntax|javascript|chij4^0|7|8|O|5|1P|6|1W|5|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|M|9|@$A|N|B|O|C|D]|$A|P|B|Q|C|D]|$A|R|B|S|C|D]|$A|T|B|U|C|D]]|E|@]|F|$]]|$2|G|4|H|6|I|8|V|9|@]|E|@]|F|$J|K]]|$2|L|4|-4|6|7|8|W|9|@]|E|@]|F|$]]]]

In addition the <code>promises</code> mentioned, you can use a <code>delay</code>. Promises have the problem that you can accidentally not deliver them, and create a deadlock scenario that's not possible with <code>future</code>s and <code>delay</code>s. The difference between a future and a delay is only the thread that the work is executed on. With a future, the work is done in the background, and with a delay the work is done by the first thread that tries to deref it. So if future's are a better fit than promises, you could always do something like:

<pre><code>(def result-1 (delay (long-calculation-1)))
(def result-2 (delay (long-calculation-2)))
(def result-3 (delay (long-calculation-3)))

(defn run-calcs []
 @(future
 @result-1
 @result-2
 @result-3))
</code></pre>

I'd like to create some futures in Clojure and run them all on a specific thread, to make sure they run one-at-a-time. Is this possible? 

It's not hard to wrap the Java libraries to do this, but before I do that I want to make sure I'm not missing a Clojure way of doing it. In Java I can do this by implementing <code>FutureTask</code> and submitting those tasks to a single-threaded executor.

How to execute some Clojure futures in a single thread?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

 我想在Clojure中创建一些未来，并在一个特定的线程上运行它们，以确保它们一次运行一个。这可能吗？ 包装Java库来实现这一点并不难，但在此之前，我希望确保不会遗漏Clojure的实现方式。在Java语言中，我可以通过实现FutureTask并将这些任务提交给单线程执行器来实现这一点。 

问如何在单个线程中执行一些Clojure期货？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在单个线程中执行一些Clojure期货？EN