本页使用了标题或全文手工转换

Future与promise

维基百科,自由的百科全书
跳到导航 跳到搜索

计算机科学中,futurepromisedelaydeferred是指用于在某些并发编程语言中同步程序执行的构造。由于某些计算(或者网络请求)尚未结束,我们需要一个对象来代理这个未知的结果,于是就有了上述这些构造(future、promise等)。

promise一词由丹尼尔·福瑞得曼和David Wise在1976年提出,[1] Peter Hibbard称之为eventual[2] 1977年Henry Baker和Carl Hewitt在一篇论文中介绍了一个类似的概念future[3]

术语futurepromisedelaydeferred通常可以互换使用,而futurepromise之间的使用差异,我们将在下面讨论。具体来说,当区分使用时,future是变量的只读占位符视图,而promise是可写的单赋值容器,用于设置future的值。 [4] 值得注意的是,无须指定可以设置其值的promise就可以定义future,并且不同的promise可以设置同一个future的值,尽管对于给定的future仅可以执行一次。在其他情况下,future和promise是一起创建的,并且相互关联:future是值,promise是设定值的函数——本质上是异步函数(promise)的返回值(future)。设置future的值的过程也称为resolve(解析)、fulfil(实现)或bind(绑定)它。

应用[编辑]

future和promise起源于函数式编程和相关范例(如逻辑编程 ),目的是将值(future)与其计算方式(promise)分离,从而允许更灵活地进行计算,特别是通过并行化。后来,它在分布式计算中得到了应用 ,减少了通信往返的延迟。再后来,它变得更有用了,因为它允许以直接风格编写异步程序,而不是以连续传递风格的方式。

隐式与显式[编辑]

对future的使用可能是隐式的(任何对future的使用都会自动获得它的值,它就像是普通的引用一样)或显式的(用户必须调用函数来获取值,例如Java中的java.util.concurrent.Futurejava.util.concurrent.CompletableFutureget方法)。获得一个显式的future的值可以称为stingingforcing。显式future可以作为库来实现,而隐式future则通常作为语言的一部分来实现。

最初的Baker和Hewitt论文描述了隐式future,它们在角色模型和纯面向对象编程语言(如Smalltalk)中自然得到支持。Friedman和Wise的论文只描述了显式的future,可能反映了在老旧硬件上有效实施隐式future的困难。难点在于老旧硬件不能处理原始数据类型(如整数)的future。例如,add指令不会处理3 + future factorial(100000) 。在纯角色模型或面向对象语言中,这个问题可以通过发送future factorial(100000)消息+[3],它要求future自己加3并返回结果。请注意,无论factorial(100000)何时完成计算,消息传递方法都可以工作,而且不需要任何sting或force。

promise流水线[编辑]

分布式系统中使用future可以显著地减少延迟。例如,future让promise流水线成为了可能,[5][6] 就像在E语言和Joule语言中实现的那样,在Argus语言中这也被称为call-stream[7]

考虑一个涉及常规远程过程调用的表达式,例如:

 t3 := ( x.a() ).c( y.b() )

可以扩展为

 t1 := x.a();
 t2 := y.b();
 t3 := t1.c(t2);

每个语句需要发送一条消息,并在下一个语句可以继续之前收到一个答复。例如,假设xyt1t2都位于同一台远程机器上。在这种情况下,在开始执行第三条语句之前,必须对该机器进行两次完整的网络往返。然后,第三条语句将引起另一个到同一个远程机器的往返。

使用future,上面的表达式可以写成

 t3 := (x <- a()) <- c(y <- b())

可以扩展为

 t1 := x <- a();
 t2 := y <- b();
 t3 := t1 <- c(t2);

这里使用的语法是E语言的语法,其中x <- a()表示将消息a()异步发送给x。所有三个变量都会立即为其结果分配future,执行过程将继续进行到后面的语句。之后尝试解决t3的值可能会导致延迟;但是,流水线操作可以减少所需的往返次数。如果与前面的示例一样,xyt1t2都位于相同的远程机器上,则流水线实现可以用一次往返来计算t3,不必用三次。由于所有三条消息都指向同一远程计算机上的对象,因此只需要发送一个请求,只需要接收一个包含结果的响应。另请注意,即使t1t2位于不同机器上,或者位于与xy不同的机器上,发送t1 <- c(t2)也不会阻塞。

promise流水线应与并行异步消息传递区分开来。在支持并行消息传递但不支持流水线操作的系统中,上面示例中的消息发送x <- a()y <- b()可以并行进行,但发送t1 <- c(t2)将不得不等到t1t2都被接收,即使xyt1t2在同一个远程机器上。在涉及许多消息的更复杂情况下,流水线的相对延迟优势变得更大。

promise流水线操作也不应与角色系统中的流水线消息处理相混淆,在这种系统中,角色可以在完成当前消息的处理之前指定并开始执行下一个消息的行为。

只读视图[编辑]

在某些编程语言(如Oz\E和AmbientTalk)中 ,可以获得未来的只读视图 ,该视图允许在resolve后读取其值,但不允许resolve它:

  • 在Oz语言中,

!!运算符用于获得只读视图

  • 在E语言和AmbientTalk中,future由一对称为promise/resolver对的值表示。promise表示只读视图,需要resolver来设置future的值。
  • 在C++11中,std::future提供了一个只读视图。该值通过使用std::promise直接设置,或使用std::packaged_taskstd::async设置为函数调用的结果。
  • 在Dojo Toolkit的1.5版本的Deferred API中, 仅限consumer的promise对象表示只读视图。[8]
  • 在Alice ML中,future提供只读视图 ,而promise包含future和resolve future的能力[9][10]
  • 在.NET 4.0中,System.Threading.Task.Task<T>表示只读视图。解析值可以通过System.Threading.Task.TaskCompletionSource<T>来完成。

对只读视图的支持符合最小特权原则,因为它允许将值设置为仅限于需要设置该值的主体。在同样支持流水线的系统中,异步消息的发送方(包括结果)接收结果的只读承诺promise,消息的目标接收resolver。

针对特定线程的future[编辑]

某些语言(如Alice ML )定义了与计算future值的特定线程相关联的future。[10] 这种计算可以在创建future时及早开始,或者在首次需要其值时懒惰地开始。在延迟计算的意义上,懒惰的future类似于thunk 。

Alice ML还支持可由任何线程解决的future,并调用这些promise[9] promise的这种使用不同于上文所述的在E语言中的使用。在Alice中,promise不是只读视图,并且不支持promise流水线操作。相反,对于future未来,包括与promise相关的future,流水线是自然而然地发生的。

阻塞与非阻塞语义[编辑]

如果future的值是异步访问的,例如通过向它发送消息,或者通过使用类似于E语言中的when的构造显式地等待它,那么在收到消息或完成等待之前,推迟到future得到resolve没有任何困难。这是在纯异步系统(如纯角色语言)中唯一需要考虑的情况。

然而,在某些系统中,还可能尝试立即同步访问未来的值。这样的话就需要做出一个设计选择:

  • 访问权限可能会阻塞当前线程或进程,直到future得到resolve(可能需要超时)。这是Oz语言中数据流变量的语义。
  • 尝试同步访问总是会发出错误信号,例如抛出异常 。这是E语言中远程promise的语义。 [11]
  • 如果future已经resolve,则访问可能成功,但如果未resolve,则发出错误信号。这样做的缺点是引入了不确定性和潜在的竞争条件,这似乎是一种不常见的设计选择。

作为第一种可能性的示例,在C++11中 ,需要future值的线程可以通过调用wait()get()成员函数来阻塞,直到可用为止。您还可以使用wait_for()wait_until()成员函数指定等待超时,以避免无限期阻塞。如果future对std::async的调用,那么阻塞等待(没有超时)可能导致函数的同步调用以计算等待线程上的结果。

相关结构[编辑]

future是Event(同步原语)的特例,只能完成一次。通常,event可以重置为初始空状态,因此可以根据需要多次完成。[12]

I-var(如在语言Id中)是具有上面定义的阻塞语义的future。I-structure是包含I-var的数据结构。可以使用不同值多次设置的相关同步构造称为M-var。M-var支持采用放置当前值的原子操作,其中取值还将M-var设置回其初始状态。 [13]

并发逻辑变量与future类似,但是通过合一更新,与逻辑编程中的逻辑变量相同。因此,它可以多次绑定到可合一的值,但不能设置回空或unresolved状态。Oz的数据流变量充当并发逻辑变量,并且还具有上面提到的阻塞语义。

并发约束变量是并发逻辑变量的一般化,以支持约束逻辑编程:约束可以多次缩小,表示可能值的较小集合。通常,有一种方法可以指定每当约束进一步缩小时应该运行的hunk;这是支持约束传播所必需的。

不同形式future的表达能力之间的关系[编辑]

通过在创建future的同时创建一个计算值的线程,可以在非线程特有的promise中直接实现及早求值的线程特有的future。在这种情况下,future将只读视图返回给客户端,以便仅让新创建的线程能够解决这个future。


要在非线程特有的promise中实现隐式延迟线程特有的promise(比如由Alice ML提供),需要一种机制来确定何时首先需要future的值(例如,Oz中的WaitNeeded构造[14] )。 如果所有值都是对象,那么实现透明转发对象的能力就足够了,因为发送给转发器的第一条消息表明需要future的值。

假定系统支持消息传递,通过让resolve线程向future自己的线程发送消息,可以在线程特有的future中实现非线程特有的future。但是,这可以被视为不必要的复杂性。在基于线程的编程语言中,最具表现力的方法似乎是提供非线程特有的future,只读视图以及WaitNeeded构造或支持透明转发的混合。

求值策略[编辑]

future的求值策略(可称为传future调用)是非确定性的:future的值将在创建future和使用其值之间的某个时间进行求值,但确切的时间不确定的,一次运行和另一次运行的求值时间会不一样。计算可以在创建future时开始(及早求值),或者仅在实际需要值时开始(懒惰求值),并且可以在中途暂停,或在一次运行中执行。一旦future被赋值,它就不会在访问future的时候重新计算;这就像传需求调用时使用的记忆化。

懒惰future是确定性具有惰性求值评估语义的future:future值的计算在首次需要时开始,与传需要调用一样。懒惰future在求值策略默认不是懒惰求值的语言中使用。例如,在C++11中,可以通过将std::launch::deferred启动策略传递给std::async以及计算值的函数来创建这种惰性future。

角色模型中的future语义[编辑]

在角色模型中,形式为future <Expression>的表达式由它对Eval消息(环境为E,客户为C)的响应方式定义:future表达式通过向客户C发送新创建的角色来响应Eval消息F (计算<Expression>的响应的代理)作为返回值,与此同时<Expression>发送环境E和客户CEval消息。F的默认行为如下:

  • F收到请求R时,它会通过评估<Expression>继续检查它是否已收到响应(可以是返回值或抛出异常),如下所示:
    1. 如果它已经有响应V,那么
      • 如果V是返回值,则发送请求R.
      • 如果V是一个异常,那么就会把这个异常抛给请求R的客户。
    2. 如果它还没有响应,则R存储在F内的请求队列中。
  • F从评估<Expression>接到响应V时,则V存储在F
    • 如果V是返回值,则将所有排队的请求发送到V.
    • 如果V是一个异常,那么就会把这个异常抛出给每个排队请求的客户。

但是,一些future可以通过特殊方式处理请求以提供更大的并行性。例如,表达式1 + future factorial(n)可以创建一个新的future,其行为类似于数字1+factorial(n) 。这个技巧并不总是有效。例如,以下条件表达式:

if m>future factorial(n) then print("bigger") else print("smaller")

会挂起,直到factorial(n)这个future已回应询问m是否大于其自身的请求。

历史[编辑]

futurepromise构造首先在诸如MultiLisp和Act 1之类的编程语言中实现。在并发逻辑编程语言中使用逻辑变量进行通信非常类似于future。这些开始于Prolog with FreezeIC Prolog,并成为真正的并发原语,包括关系语言、Concurrent Prolog、守卫霍恩子句(GHC)、Parlog、Strand、Vulcan、Janus、Oz-Mozart、Flow Java和Alice ML。来自数据流编程语言的单一赋值I-var ,源自Id并包含在Reppy的Concurrent ML中,非常类似于并发逻辑变量。

promise流水线技术(使用future来克服延迟)是Barbara Liskov和Liuba Shrira于1988年发明的[7],由Mark S. Miller、Dean Tribble和Rob Jellinghaus在大约1989年的Xanadu项目中独立发明。[15]

promise一词是由Liskov和Shrira创造的,尽管他们通过名称call-stream引用了流水线机制,现在很少使用它。

Liskov和Shrira的论文中描述的设计以及Xanadu中的promise流水线的实现都有一个限制,即promise值不是一等的:一个参数,或者一个call或send返回的值不能直接成为一个promise (所以前面给出的promise流水线的例子,它使用一个发送的结果作为另一个发送的参数的承诺,在call-stream设计或Xanadu实现中不能直接表达)。似乎promise和call-stream从未在Argus的任何公开发布中实现, [16] Liskov和Shrira论文中使用的编程语言。Argus的开发在1988年左右停止了。[17] Xanadu实现的promise流水线仅在1999年Udanax Gold[18]的源代码发布时才公开发布,并且在任何已发布的文档中都没有解释过。[19] Joule和E的后续实现支持完全一等的promise和resolver。

一些早期的角色语言,包括Act系列,[20][21] 支持并行消息传递和流水线消息处理,但不支持promise流水线。(虽然技术上可以在前两个中实现最后一个功能,但没有证据表明Act语言这样做了。)

2000年之后,由于消息传递的请求-响应模型,future和promise在用户界面响应和web开发中的应用重新引起了人们的兴趣。现在有几种主流语言对future和promise都有语言支持,最着名的是Java 5中的FutureTask(2004年公布)[22]以及.NET 4.5中的asyncawait结构(2010年发布,2012年发布)[23][24]很大程度上受到F#的异步工作流程(可追溯到2007年[25])的启发[26]。 随后被其他语言采用,特别是Dart(2014)[27],Python(2015)[28], Hack(HHVM)以及ECMAScript 7(JavaScript)、Scala和C++的草案。

实现列表[编辑]

支持future、promise、并发逻辑变量、数据流变量或I-vars的语言,无论是通过直接语言支持还是在标准库中,包括:

还支持promise流水线的语言包括:

  • E
  • Joule

基于非标准库的future实现:

  • 对于Common Lisp
  • 对于C++:
  • 对于C#和其他.NET语言:Parallel Extensions库
  • 对于Groovy:GPars[49]
  • 对于JavaScript
    • Cujo.js'[50] when.js[51]提供符合Promises/A+[52] 1.1规范的promise
    • Dojo Toolkit提供promises[53]和Twisted方式延迟
    • MochiKit [54]受Twisted's Deferreds的启发
    • jQuery的 Deferred Object基于CommonJS Promises/A设计。
    • Angularjs[55]
    • node-promise[56]
    • Q,作者为Kris Kowal,符合Promises/A+ 1.1[57]
    • RSVP.js,符合Promises/A+ 1.1[58]
    • YUI的[59]promise类[60]符合Promises/A+ 1.0规范。
    • Bluebird,作者Petka Antonov[61]
    • Closure Library的promise包符合Promises/A+规范。
    • 有关基于Promise/A+设计的更多实现,请参阅Promise/A+列表。
  • 对于Java
    • JDeferred提供了与JQuery类似的deferred-promise API和行为。Deferred对象[62]
    • ParSeq[63]提供task-promise API,由LinkedIn维护,适用于异步流水线和分支
  • 对于Objective-C:MAFuture[64][65]、RXPromise[66]、ObjC-CollapsingFutures[67]、PromiseKit[68]、objc-promise[69]、OAPromise[70]
  • 对于OCaml:Lazy模块实现了懒惰的显式期货[71]
  • 对于Perl:Future[72]、Promises[73]、和Reflex[74]
  • 对于PHP:React/Promise [75]
  • 对于Python
  • 对于R
    • future,实现可扩展的future API与懒惰和及早同步和(多核或分布式)异步期货[79] [80]
  • 对于Ruby
    • Promise gem[81]
    • libuv gem,实现promise[82]
    • Celluloid gem,实现future[83]
    • future-resource[84]
  • 对于Rust:
  • 对于Scala
    • Twitter的util库[86]
  • 对于Swift:
    • 异步框架,实现C#风格的async/非阻塞await[87]
    • FutureKit[88]、实现了Apple GCD的版本[89]
    • FutureLib,纯Swift 2库实现的Scala风格的future和promise与TPL风格的取消[90]
    • Deferred,纯Swift库,受到OCaml的Deferred启发[91]
    • BrightFutures[92]
  • 对于Tcl:tcl-promise[93]

协程[编辑]

future可以用协程[28]或生成器实现,[94] 从而产生相同的评估策略(例如,协同多任务或延迟评估)。

channel[编辑]

future可以很容易地用channel实现:future是一个单元素的channel,而promise是一个发送到channel,实现future的过程。 [95] [96] 这允许future在支持channel(如CSP和Go)的并发编程语言中实现。由此产生的future是显式的,因为它们必须通过从channel读取而不是仅仅通过评估来获取。

参见[编辑]

参考资料[编辑]

  1. ^ Friedman, Daniel; David Wise. The Impact of Applicative Programming on Multiprocessing. International Conference on Parallel Processing: 263–272. 1976. 
  2. ^ Hibbard, Peter. Parallel Processing Facilities. New Directions in Algorithmic Languages, (ed.) Stephen A. Schuman, IRIA, 1976. 1976. 
  3. ^ Henry Baker; Carl Hewitt. The Incremental Garbage Collection of Processes. Proceedings of the Symposium on Artificial Intelligence Programming Languages,. ACM Sigplan Notices 12, 8: 55–59. August 1977. 
  4. ^ "SIP-14 – Futures and Promises"
  5. ^ Promise Pipelining. www.erights.org. 
  6. ^ Promise Pipelining on the C2 wiki
  7. ^ 7.0 7.1 Barbara Liskov; Liuba Shrira. Promises: Linguistic Support for Efficient Asynchronous Procedure Calls in Distributed Systems. Proceedings of the SIGPLAN '88 Conference on Programming Language Design and Implementation; Atlanta, Georgia, United States. ACM: 260–267. 1988. ISBN 0-89791-269-1. doi:10.1145/53990.54016.  Also published in ACM SIGPLAN Notices 23(7).
  8. ^ Robust promises with Dojo deferred, Site Pen, 2010-05-03 
  9. ^ 9.0 9.1 Promise, Alice Manual, DE: Uni-SB 
  10. ^ 10.0 10.1 Future, Alice manual, DE: Uni-SB 
  11. ^ Promise, E rights 
  12. ^ 500 lines or less, "A Web Crawler With asyncio Coroutines" by A. Jesse Jiryu Davis and Guido van Rossum says "implementation uses an asyncio.Event in place of the Future shown here. The difference is an Event can be reset, whereas a Future cannot transition from resolved back to pending."
  13. ^ Control Concurrent MVar, Haskell, (原始内容存档于2009-04-18) 
  14. ^ WaitNeeded, Mozart Oz 
  15. ^ Promise, Sunless Sea, (原始内容存档于2007-10-23) 
  16. ^ Argus, MIT 
  17. ^ Liskov, Barbara, Distributed computing and Argus, Oral history, IEEE GHN 
  18. ^ Gold, Udanax, (原始内容存档于2008-10-11) 
  19. ^ Pipeline, E rights 
  20. ^ Henry Lieberman. A Preview of Act 1. MIT AI memo 625. June 1981. 
  21. ^ Henry Lieberman. Thinking About Lots of Things at Once without Getting Confused: Parallelism in Act 1. MIT AI memo 626. June 1981. 
  22. ^ Goetz, Brian. Concurrency in JDK 5.0. 2004-11-23. 
  23. ^ 23.0 23.1 Async in 4.5: Worth the Await – .NET Blog – Site Home – MSDN Blogs. Blogs.msdn.com. [2014-05-13]. 
  24. ^ 24.0 24.1 24.2 Asynchronous Programming with Async and Await (C# and Visual Basic). Msdn.microsoft.com. [2014-05-13]. 
  25. ^ Don Syme; Tomas Petricek; Dmitry Lomov. The F# Asynchronous Programming Model, PADL 2011. 2010-10-21. 
  26. ^ Tomas Petricek. Asynchronous C# and F# (I.): Simultaneous introduction. 2010-10-29. 
  27. ^ 27.0 27.1 Gilad Bracha. Dart Language Asynchrony Support: Phase 1. October 2014. 
  28. ^ 28.0 28.1 PEP 0492 – Coroutines with async and await syntax. 
  29. ^ Kenjiro Taura; Satoshi Matsuoka; Akinori Yonezawa. ABCL/f: A Future-Based Polymorphic Typed Concurrent Object-Oriented Language – Its Design and Implementation.. In Proceedings of the DIMACS workshop on Specification of Parallel Algorithms, number 18 in Dimacs Series in Discrete Mathematics and Theoretical Computer Science. American Mathematical Society: 275–292. 1994.  已忽略未知参数|citeseerx= (帮助)
  30. ^ Dart SDK dart async Completer. 
  31. ^ Task. 
  32. ^ Steve Dekorte. Io, The Programming Language. 2005. 
  33. ^ Rich Hickey. changes.txt at 1.1.x from richhickey's clojure. 2009. 
  34. ^ Seif Haridi; Nils Franzen. Tutorial of Oz. Mozart Global User Library. [2011-04-12]. 
  35. ^ Perl 6中的Promise类. docs.perl6.org. 
  36. ^ Python 3.2 发布. Python.org. 
  37. ^ Python 3.5.0 发布. Python.org. 
  38. ^ Parallelism with Futures. PLT. [2012-03-02]. 
  39. ^ Blackbird promise library - Blackbird. orthecreedence.github.io. 
  40. ^ Eager Future2. common-lisp.net. 
  41. ^ - Common Lisp的并行编程库[永久失效連結]
  42. ^ PCall. marijnhaverbeke.nl. 
  43. ^ Chapter 30. Thread 4.0.0. [2013-06-26]. 
  44. ^ Dlib C++ Library #thread_pool. [2013-06-26]. 
  45. ^ QtCore 5.0: QFuture Class. Qt Project. [2013-06-26]. [永久失效連結]
  46. ^ Seastar. Seastar project. [2016-08-22]. 
  47. ^ GitHub – facebook/folly: An open-source C++ library developed and used at Facebook.. 
  48. ^ Threads Slides of POCO (PDF). 
  49. ^ Groovy GPars 互联网档案馆存檔,存档日期2013-01-12.
  50. ^ cujoJS: Javascript architectural toolkit. cujojs.com. 
  51. ^ A solid, fast Promises/A+ and when() implementation, plus other async goodies.: cujojs/when. 2018-12-25 –通过GitHub. 
  52. ^ Promises/A+. promisesaplus.com. 
  53. ^ Dojo Deferreds and Promises - Archived Tutorial - Dojo Toolkit. dojotoolkit.org. 
  54. ^ manage asynchronous tasks. MochiKit.Async. [2019-01-04]. 
  55. ^ AngularJS — Superheroic JavaScript MVW Framework. angularjs.org. 
  56. ^ Promise utilities for Node. Contribute to kriszyp/node-promise development by creating an account on GitHub. 2018-10-22 –通过GitHub. 
  57. ^ kriskowal/q. documentup.com. 
  58. ^ A lightweight library that provides tools for organizing asynchronous code: tildeio/rsvp.js. 2019-01-03 –通过GitHub. 
  59. ^ YUI Javascript 类库. yuilibrary.com. 
  60. ^ Promise - YUI Library. yuilibrary.com. 
  61. ^ :bird: :zap: Bluebird is a full featured promise library with unmatched performance.: petkaantonov/bluebird. 2019-01-04 –通过GitHub. 
  62. ^ JDeferred. JDeferred. 
  63. ^ Asynchronous Java made easier. Contribute to linkedin/parseq development by creating an account on GitHub. 2018-12-29 –通过GitHub. 
  64. ^ Proxying futures library for Objective-C. Contribute to mikeash/MAFuture development by creating an account on GitHub. 2019-01-01 –通过GitHub. 
  65. ^ mikeash.com: Friday Q&A 2010-02-26: Futures. www.mikeash.com. 
  66. ^ An Objective-C Class which implements the Promises/A+ specification.: couchdeveloper/RXPromise. 2018-12-26 –通过GitHub. 
  67. ^ Futures, for Objective-C, that automatically collapse so it's nearly impossible to mix up the level of future nesting despite the lack of generics.: Strilanc/ObjC-CollapsingFutures. 2018-12-07 –通过GitHub. 
  68. ^ Promises for Swift & ObjC. Contribute to mxcl/PromiseKit development by creating an account on GitHub. 2019-01-03 –通过GitHub. 
  69. ^ Objective-C Promises in the CommonJS style. Contribute to mproberts/objc-promise development by creating an account on GitHub. 2018-09-11 –通过GitHub. 
  70. ^ OAPromise is an API separating async operations and their callbacks, adding consistency and useful features like fall-through errors and progress reports.: oleganza/OAPromise. 2017-03-29 –通过GitHub. 
  71. ^ Lazy. caml.inria.fr. 
  72. ^ Future - represent an operation awaiting completion - metacpan.org. metacpan.org. 
  73. ^ Promises - An implementation of Promises in Perl - metacpan.org. metacpan.org. 
  74. ^ Reflex - Class library for flexible, reactive programs. - metacpan.org. metacpan.org. 
  75. ^ Promises/A implementation for PHP. Contribute to reactphp/promise development by creating an account on GitHub. 2019-01-04 –通过GitHub. 
  76. ^ Coroutines and Tasks — Python 3.7.2 documentation. docs.python.org. 
  77. ^ Google Code Archive - Long-term storage for Google Code Project Hosting.. code.google.com. 
  78. ^ Deferred Reference — Twisted 18.9.0 documentation. twistedmatrix.com. 
  79. ^ Bengtsson, Henrik. future: Unified Parallel and Distributed Processing in R for Everyone. 2018-10-17 –通过R-Packages. 
  80. ^ Bengtsson, Henrik. future: Unified Parallel and Distributed Processing in R for Everyone. 2018-10-17 –通过R-Packages. 
  81. ^ promise - RubyGems.org - your community gem host. rubygems.org. 
  82. ^ Ruby bindings for libuv. Contribute to cotag/libuv development by creating an account on GitHub. 2018-10-16 –通过GitHub. 
  83. ^ Celluloid: Actor-based Concurrent Objects for Ruby. celluloid.io. 
  84. ^ Wait on resources being set in the future. Contribute to adhearsion/future-resource development by creating an account on GitHub. 2013-12-27 –通过GitHub. 
  85. ^ Zero-cost asynchronous programming in Rust. Contribute to rust-lang-nursery/futures-rs development by creating an account on GitHub. 2019-01-04 –通过GitHub. 
  86. ^ Util. twitter.github.io. 
  87. ^ al45tair / Async. bitbucket.org. 
  88. ^ A Swift based Future/Promises Library for IOS and OS X.: FutureKit/FutureKit. 2018-12-31 –通过GitHub. 
  89. ^ Dispatch - Apple Developer Documentation. developer.apple.com. 
  90. ^ FutureLib is a pure Swift 2 library implementing Futures & Promises inspired by Scala.: couchdeveloper/FutureLib. 2018-10-15 –通过GitHub. 
  91. ^ Work with values that haven't been determined yet.: bignerdranch/Deferred. 2019-01-02 –通过GitHub. 
  92. ^ Write great asynchronous code in Swift using futures and promises: Thomvis/BrightFutures. 2019-01-03 –通过GitHub. 
  93. ^ tcl-promise. SourceForge. 
  94. ^ Does async/await solve a real problem?. esdiscuss.org. 
  95. ^ Futures - Go Language Patterns. www.golangpatterns.info. 
  96. ^ Go Language Patterns. www.golangpatterns.info. 

外部链接[编辑]