Futures und Versprechen

Im Informatik, Zukunft, versprechen, Verzögerung, und aufgeschoben Siehe Konstrukte für verwendet für Synchronisierung Programm Hinrichtung in einigen Gleichzeitige Programmiersprachen. Sie beschreiben ein Objekt, das als Stellvertreter für ein zunächst unbekanntes Ergebnis wirkt, normalerweise weil die Berechnung von seinem Wert ist noch nicht vollständig.

Der Begriff versprechen wurde 1976 von vorgeschlagen von Daniel P. Friedman und David weise,^[1] Und Peter Hibbard nannte es eventuell.^[2] Ein etwas ähnliches Konzept Zukunft wurde 1977 in einem Papier von vorgestellt von Henry Baker und Carl Hewitt.^[3]

Die Begriffe Zukunft, versprechen, Verzögerung, und aufgeschoben werden oft austauschbar verwendet, obwohl einige Unterschiede in der Nutzung zwischen Zukunft und versprechen werden unten behandelt. Insbesondere, wenn die Verwendung unterschieden wird, ist eine Zukunft a schreibgeschützt Platzhalteransicht einer Variablen, während ein Versprechen ein beschreibbares ist, ist einzelne Zuordnung Container, der den Wert der Zukunft festlegt. Insbesondere kann eine Zukunft definiert werden, ohne anzugeben, welches spezifische Versprechen ihren Wert festlegen wird, und unterschiedliche mögliche Versprechen können den Wert einer bestimmten Zukunft festlegen, obwohl dies nur einmal für eine bestimmte Zukunft erfolgen kann. In anderen Fällen werden eine Zukunft und ein Versprechen zusammen geschaffen und miteinander verbunden: Die Zukunft ist der Wert, das Versprechen ist die Funktion, die den Wert festlegt - im Wesentlichen den Rückgabewert (Zukunft) einer asynchronen Funktion (Versprechen). Das Festlegen des Wertes einer Zukunft wird ebenfalls genannt Lösung, erfüllend, oder Bindung es.

Anwendungen

Futures und Versprechen stammten von Funktionelle Programmierung und verwandte Paradigmen (wie z. Logikprogrammierung), um einen Wert (eine Zukunft) von der Berechnung (ein Versprechen) zu entkoppeln, sodass die Berechnung flexibler durchgeführt werden kann, insbesondere durch Parallelisierung. Später fand es verwendet in verteiltes Computer, bei der Reduzierung der Latenz von Kommunikationsrundreisen. Später nutzte es mehr, indem es das Schreiben asynchroner Programme in erlaubte direkter Stileher als in Fortsetzungsstil.

Implizit gegen explizit

Die Verwendung von Futures kann sein implizit (Jede Verwendung der Zukunft erhält automatisch ihren Wert, als wäre sie gewöhnlich Hinweis) oder explizit (Der Benutzer muss eine Funktion aufrufen, um den Wert zu erhalten, wie z. erhalten Methode von java.util.concurrent.futurein Java). Das Erhalten des Wertes einer expliziten Zukunft kann genannt werden stechen oder zwingen. Explizite Futures können als Bibliothek implementiert werden, während implizite Futures normalerweise als Teil der Sprache implementiert werden.

Das ursprüngliche Bäcker- und Hewitt -Papier beschrieben implizite Futures, die natürlich in der unterstützt werden Schauspielermodell von Berechnung und rein Objekt orientierte Programmierung Sprachen mögen Smalltalk. Das Friedman und das weise Papier beschrieben nur explizite Futures, was wahrscheinlich die Schwierigkeit widerspiegelt, implizite Zukunftsbetreuung auf Lagerhardware effizient implementiert zu werden. Die Schwierigkeit besteht darin, dass Aktienhardware nicht mit Futures für primitive Datentypen wie Ganzzahlen verfügt. Zum Beispiel weiß eine Add -Anweisung nicht, wie man umgeht 3 + zukünftige Fakultäten (100000). In reinen Schauspieler oder Objektsprachen kann dieses Problem durch Senden gelöst werden zukünftige Fakultäten (100000) die Nachricht +[3], was die Zukunft auffordert, hinzuzufügen 3 zu sich selbst und zurückgeben das Ergebnis. Beachten Sie, dass der Ansatz des Nachrichtenübergangs unabhängig von wann funktioniert Fakultät (100000) beendet die Berechnung und es ist kein Stecher/Erzwingen erforderlich.

Versprechen Sie Pipelining

Die Verwendung von Futures kann sich dramatisch verringern Latenz in verteilte Systeme. Zum Beispiel ermöglichen Futures Versprechen Sie Pipelining,^[4][5] wie in den Sprachen implementiert E und Joule, was auch genannt wurde Rufstream^[6] in der Sprache Argus.

Betrachten Sie einen Ausdruck, der konventionell ist Remote -Verfahrensanrufe, wie zum Beispiel:

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

das könnte erweitert werden auf

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

Jede Anweisung muss eine Nachricht gesendet werden, und eine Antwort, die vor der nächsten Anweisung erhalten wird. Nehmen wir zum Beispiel das an, das x, y, t1, und t2 befinden sich alle auf derselben Fernmaschine. In diesem Fall müssen zwei vollständige Netzwerk-Roundtrips zu diesem Computer stattfinden, bevor die dritte Anweisung ausgeführt werden kann. Die dritte Aussage führt dann zu einem weiteren Hindernis für die gleiche Fernmaschine.

Mit Futures könnte der obige Ausdruck geschrieben werden

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

das könnte erweitert werden auf

 T1: = x <- a (); T2: = y <- b (); T3: = T1 <- C (T2);

Die hier verwendete Syntax ist die der Sprache e, wo x <- a () bedeutet, die Nachricht zu senden a() asynchron zu x. Alle drei Variablen werden für ihre Ergebnisse sofort zugewiesen, und die Ausführung geht nach nachfolgenden Aussagen. Spätere Versuche, den Wert von zu lösen T3 kann eine Verzögerung verursachen; Pipelining kann jedoch die Anzahl der erforderlichen Hin- und Rückfahrten verringern. Wenn, wie im vorherigen Beispiel, x, y, t1, und t2 befinden sich alle auf derselben Fernmaschine, eine Pipelined -Implementierung kann berechnet werden T3 mit einem Hin- und Rückflug statt von drei. Da alle drei Nachrichten für Objekte bestimmt sind, die sich auf derselben Remote -Maschine befinden, muss nur eine Anforderung gesendet werden und nur eine Antwort benötigt, die das Ergebnis enthält. Der Send T1 <- C (T2) würde nicht blockieren, selbst wenn t1 und t2 waren auf verschiedenen Maschinen zueinander oder zu x oder y.

Das Versprechen -Pipelining sollte von einer parallelen asynchronen Botschaft unterschieden werden. In einem System, das eine parallele Nachricht unterstützt, aber nicht pipelining, sendet die Nachricht x <- a () und y <- b () im obigen Beispiel konnte parallel fortgesetzt, aber der Senden von von T1 <- C (T2) müsste bis beides warten t1 und t2 war empfangen worden, auch wenn x, y, t1, und t2 sind auf derselben Fernmaschine. Der relative Latenzvorteil der Pipelinierung wird in komplizierteren Situationen mit vielen Nachrichten noch größer.

Das Versprechen von Pipelining sollte auch nicht verwechselt werden Pipeline -Nachrichtenverarbeitung In Akteursystemen, wo es einem Akteur möglich ist, ein Verhalten für die nächste Nachricht auszuführen und zu beginnen, bevor die Verarbeitung der aktuellen Nachricht abgeschlossen ist.

Schreibgeschützte Ansichten

In einigen Programmiersprachen wie z. Oz, E, und AmbienttalkEs ist möglich, a zu erhalten schreibgeschützte Ansicht einer Zukunft, die es ermöglicht, ihren Wert bei der Auflösung zu lesen, aber nicht die Lösung von ihm zulässt:

• In Oz die !! Der Bediener wird verwendet, um eine schreibgeschützte Ansicht zu erhalten.
• In E und Ambienttalk wird eine Zukunft durch zwei Wertepaare als a dargestellt Versprechen/Resolverpaar. Das Versprechen stellt die schreibgeschützte Ansicht dar, und der Resolver ist erforderlich, um den Wert der Zukunft festzulegen.
• Im C ++ 11 a STD :: Zukunft Bietet eine schreibgeschützte Ansicht. Der Wert wird direkt mit a eingestellt STD :: Versprechen, oder auf das Ergebnis eines Funktionsaufrufs eingestellt werden std :: packaged_task oder std :: asynchron.
• In dem Dojo -Toolkit's aufgeschobene API ab Version 1.5, a Verbraucher nur Verbraucher stellt eine schreibgeschützte Ansicht dar.^[7]
• Im Alice Ml, Futures liefern a schreibgeschützte Ansicht, während ein Versprechen sowohl eine Zukunft als auch die Fähigkeit enthält, die Zukunft zu lösen^[8][9]
• Im .NET Framework 4.0 System.Threading.tasks.task stellt eine schreibgeschützte Ansicht dar. Das Auflösen des Wertes kann über durch System.Threading.Tasks.TaskCompletionsource.

Die Unterstützung für schreibgeschützte Ansichten steht im Einklang mit dem Prinzip der geringsten Privilegienda es die Möglichkeit ermöglicht, den Wert festzulegen, auf den eingeschränkt werden kann Themen das muss es setzen. In einem System, das auch Pipelining unterstützt, erhält der Absender einer asynchronen Nachricht (mit Ergebnis) das schreibgeschützte Versprechen für das Ergebnis, und das Ziel der Nachricht empfängt den Resolver.

Thread-spezifische Zukunft

Einige Sprachen, wie z. Alice MlDefinieren Sie Futures, die mit einem bestimmten Thread verbunden sind, der den Wert der Zukunft berechnet.^[9] Diese Berechnung kann entweder beginnen eifrig Wenn die Zukunft erstellt wird, oder träge Wenn sein Wert zum ersten Mal benötigt wird. Eine faule Zukunft ähnelt einem Thunkim Sinne einer verzögerten Berechnung.

Alice ML unterstützt auch Futures, die von jedem Thread gelöst werden können, und ruft diese auf Versprechen.^[8] Diese Verwendung von versprechen unterscheidet sich von seiner Verwendung in E wie beschrieben Oben. In Alice ist ein Versprechen keine schreibgeschützte Sichtweise, und das Versprechen-Pipelining wird nicht unterstützt. Stattdessen erfolgt das Pipelining natürlich für Futures, einschließlich derjenigen, die mit Versprechen verbunden sind.

Blockieren gegen nicht blockierende Semantik

Wenn auf den Wert einer Zukunft asynchron zugegriffen wird, zum Beispiel durch Senden einer Nachricht an sie oder durch explizites Warten auf ein Konstrukt wie z. Wenn In E gibt es keine Schwierigkeit, sich zu verzögern, bis die Zukunft gelöst wird, bevor die Nachricht empfangen oder die Wartezeit abgeschlossen wird. Dies ist der einzige Fall, der in rein asynchronen Systemen wie reinen Schauspielersprachen berücksichtigt wird.

In einigen Systemen kann es jedoch auch möglich sein, es zu versuchen sofort oder synchron Zugang zu dem Wert einer Zukunft. Dann gibt es eine Designauswahl zu treffen:

• Der Zugriff kann den aktuellen Thread oder den aktuellen Prozess blockieren, bis die Zukunft aufgelöst wird (möglicherweise mit einer Auszeit). Dies ist die Semantik von Datenflussvariablen in der Sprache Oz.
• Der versuchte synchrone Zugriff kann immer einen Fehler signalisieren, beispielsweise ein Werfen eines Ausnahme. Dies ist die Semantik von Fernversprechen in E.^[10]
• Möglicherweise könnte der Zugriff erfolgreich sein, wenn die Zukunft bereits aufgelöst ist, jedoch einen Fehler signalisieren, wenn dies nicht der Fall ist. Dies hätte den Nachteil, den Nichtdeterminismus einzuführen und das Potenzial für Rennbedingungenund scheint eine ungewöhnliche Designwahl zu sein.

Als Beispiel für die erste Möglichkeit in C ++ 11, ein Thread, der den Wert einer Zukunft benötigt, kann blockieren, bis er verfügbar ist Warten() oder erhalten() Mitgliedsfunktionen. Sie können auch eine Zeitüberschreitung auf der Wartezeit mit dem angeben warten auf() oder warte bis() Mitgliedsfunktionen, um eine unbestimmte Blockierung zu vermeiden. Wenn die Zukunft aus einem Aufruf an entstand std :: asynchron Dann kann ein Blockierungswart (ohne Auszeit) eine synchrone Aufruf der Funktion verursachen, um das Ergebnis auf dem wartenden Thread zu berechnen.

Verwandte Konstrukte

Futures sind ein besonderer Fall der Synchronisation Primitive "Veranstaltungen, "Welches kann nur einmal fertiggestellt werden. Im Allgemeinen können Ereignisse auf den anfänglichen leeren Zustand zurückgesetzt und so viele Male wie Sie möchten.^[11]

Ein I-var (wie in der Sprache Ausweis) ist eine Zukunft mit Blockierung der Semantik wie oben definiert. Ein I-struktur ist ein Datenstruktur I-Vars enthalten. Ein verwandtes Synchronisationskonstrukt, das mehrmals mit unterschiedlichen Werten festgelegt werden kann M-var. M-VARs unterstützen atomare Operationen zu nehmen oder stellen Der aktuelle Wert, bei dem der Wert auch den M-VAR auf seine Anfangswerte zurückführt leer Zustand.^[12]

A Gleichzeitige Logikvariable ähnelt einer Zukunft, wird aber von aktualisiert von Vereinigung, so wie Logikvariablen in Logikprogrammierung. Somit kann es mehr als einmal an unifierbare Werte gebunden werden, kann jedoch nicht in einen leeren oder ungelösten Zustand zurückgesetzt werden. Die Datenflow -Variablen von OZ wirken als gleichzeitige Logikvariablen und blockieren auch die oben erwähnte Semantik.

A Gleichzeitige Einschränkungsvariable ist eine Verallgemeinerung der gleichzeitigen Logikvariablen zur Unterstützung Einschränkung der Logikprogrammierung: Die Einschränkung kann sein verengt Mehrmals, was kleinere Werte angeben. Normalerweise gibt es eine Möglichkeit, einen Thunk anzugeben, der ausgeführt werden sollte, wenn die Einschränkung weiter eingeschränkt wird. Dies ist erforderlich, um zu unterstützen Einschränkungsausbreitung.

Beziehungen zwischen der Ausdruckskraft verschiedener Formen der Zukunft

Egere fadenspezifische Futures können in nicht-threadspezifischen Futures unkompliziert implementiert werden, indem ein Thread erstellt wird, um den Wert gleichzeitig mit der Erstellung der Zukunft zu berechnen. In diesem Fall ist es wünschenswert, eine schreibgeschützte Ansicht an den Client zurückzugeben, so dass nur der neu erstellte Thread diese Zukunft beheben kann.

Um implizite faule threadspezifische Zukunft (wie von Alice ML angegeben) in nicht threadspezifischen Zukunft zu implementieren, benötigt ein Mechanismus, um festzustellen, wann der Wert der Zukunft zuerst erforderlich ist (z. B. die, die Warten Sie gebunden Konstrukt in oz^[13]). Wenn alle Werte Objekte sind, ist die Fähigkeit, transparente Weiterleitungsobjekte zu implementieren, ausreichend, da die erste an den Spediteur gesendete Nachricht angibt, dass der Wert der Zukunft erforderlich ist.

Nicht threadspezifische Zukunftsfutures können in threadspezifischen Futures implementiert werden, vorausgesetzt, das System unterstützt das Übergeben von Nachrichten, indem der Auflösungs-Thread eine Nachricht an den eigenen Thread der Zukunft sendet. Dies kann jedoch als nicht benötigte Komplexität angesehen werden. In Programmiersprachen, die auf Threads basieren, scheint der ausdrucksvollste Ansatz darin bestehen, eine Mischung aus nicht-threadspezifischen Zukunft, schreibgeschützten Ansichten und entweder einer schreibgeschützten Ansichten bereitzustellen Warten Sie gebunden Konstruktion oder Unterstützung für die transparente Weiterleitung.

Bewertungsstrategie

Das Bewertungsstrategie von Futures, die bezeichnet werden können Rufen Sie nach Zukunft an, ist nicht deterministisch: Der Wert einer Zukunft wird zu einem bestimmten Zeitpunkt zwischen der Erstellung der Zukunft und dem Wert, wenn ihr Wert verwendet wird, aber die genaue Zeit wird vorher nicht bestimmt und kann sich von Lauf zum Lauf ändern. Die Berechnung kann beginnen, sobald die Zukunft erstellt wird (eifrige Bewertung) oder nur wenn der Wert tatsächlich benötigt wird (faule Bewertung) und kann Teil des Teils durchgesetzt oder in einem Lauf ausgeführt werden. Sobald der Wert einer Zukunft zugewiesen ist, wird sie nicht auf zukünftige Zugriffe neu berechnet. Das ist wie das Memoisierung benutzt in Rufen Sie nach Bedarf an.

A Faule Zukunft Ist eine Zukunft, die deterministischerweise eine faule Bewertungssemantik hat: Die Berechnung des Wertes der Zukunft beginnt, wenn der Wert zum ersten Mal benötigt wird, wie in Call nach Bedarf. Lazy Futures sind in Sprachen von Nutzen, die die Bewertungsstrategie standardmäßig nicht faul ist. Zum Beispiel in C ++ 11 Solche faulen Zukunftsfutures können durch Bestehen des STD :: Start :: Deferred Startpolitik an std :: asynchronzusammen mit der Funktion, um den Wert zu berechnen.

Semantik der Futures im Schauspielermodell

Im Schauspielermodell ein Ausdruck der Form Zukunft wird definiert dadurch, wie es auf eine reagiert Bewerten Nachricht mit Umgebung E und Kunde C wie folgt: Der zukünftige Ausdruck reagiert auf die Bewerten Nachricht durch Senden des Kunden C ein neu erstellter Schauspieler F (Der Proxy zur Reaktion der Bewertung ) als Rückgabewert gleichzeitig mit Senden ein Bewerten Nachricht mit Umgebung E und Kunde C. Das Standardverhalten von F ist wie folgt:

• Wann F erhält eine Anfrage RAnschließend prüft es, ob es bereits eine Antwort erhalten hat (die entweder ein Rückgabewert oder eine geworfene Ausnahme sein kann) von der Bewertung Fortschritte wie folgt:
  1. Wenn es bereits eine Antwort hat V, dann
     • Wenn V ist ein Rückgabewert, dann wird die Anfrage gesendet R.
     • Wenn V ist eine Ausnahme, dann wird es dem Kunden der Anfrage geworfen R.
  2. Wenn es noch keine Antwort gibt, dann R wird in der Warteschlange von Anfragen in der Aufbewahrung gespeichert F.
• Wann F erhält die Antwort V von der Bewertung , dann V ist in gelagert F und
  • Wenn V ist ein Rückgabewert, dann werden alle Anfragen in die Warteschlange gesendet V.
  • Wenn V ist eine Ausnahme, dann wird es an den Kunden jeder der Anfragen in der Warteschlange geworfen.

Einige Futures können jedoch mit Anfragen auf besondere Weise umgehen, um eine größere Parallelität zu ermöglichen. Zum Beispiel der Ausdruck 1 + zukünftige Fakultät (n) kann eine neue Zukunft schaffen, die sich wie die Nummer verhalten wird 1+faktorial (n). Dieser Trick funktioniert nicht immer. Zum Beispiel der folgende bedingte Ausdruck:

Wenn m> Future Factorial (n) dann drucken ("größer") sonst drucken ("kleiner")

bis die Zukunft für die Zukunft für faktorial (n) hat auf die Anfrage beantwortet gefragt, ob m ist größer als sich selbst.

Geschichte

Das Zukunft und/oder versprechen Konstrukte wurden erstmals in Programmiersprachen wie z. Multilisp und Akt 1. Die Verwendung von Logikvariablen für die Kommunikation in gleichzeitig Logikprogrammierung Sprachen waren Futures ziemlich ähnlich. Diese begannen in Prolog mit Einfrieren und IC Prologund wurde zu einer wahren Parallelitätsprimitiv mit der relationalen Sprache, gleichzeitig Prolog, bewacht Hornklauseln (GHC), Parlog, Strand, Vulkan, Janus, Oz-Mozart, Flow Java, und Alice Ml. Die Einzelausrichtung I-var aus Datenflow -Programmierung Sprachen, die von Ursprung in Ausweis und in Reppy's enthalten Gleichzeitiger ML, ist ähnlich wie die gleichzeitige Logikvariable.

Die Versprechen -Pipelining -Technik (mit Futures zur Überwindung der Latenz) wurde von erfunden Barbara Liskov und Liuba Shrira 1988,,^[6] und unabhängig von Mark S. Miller, Dean Tribble und Rob Jellinghaus im Kontext von Projekt Xanadu ca. 1989.^[14]

Der Begriff versprechen wurde von Liskov und Shrira geprägt, obwohl sie den Pipelining -Mechanismus mit dem Namen verwiesen haben Rufstream, was jetzt selten verwendet wird.

Sowohl das in Liskov als auch das Papier von Shrira beschriebene Design und die Umsetzung von Versprechen -Pipelining in Xanadu hatten die Grenze, dass Versprechenswerte nicht waren erste Klasse: Ein Argument für oder der Wert, der durch einen Anruf oder Senden zurückgegeben wird direkt ausdrückbar im Call-Stream-Design oder in der Xanadu-Implementierung). Es scheint, dass Versprechen und Anrufstreams in keiner öffentlichen Freilassung von Argus umgesetzt wurden.^[15] Die im Liskov- und Shrira -Papier verwendete Programmiersprache. Die Entwicklung von Argus hörte um 1988 auf.^[16] Die Xanadu -Implementierung von Promise Pipelining wurde nur mit der Veröffentlichung des Quellcode für Udanax Gold öffentlich verfügbar^[17] 1999 und wurde nie in einem veröffentlichten Dokument erklärt.^[18] Die späteren Implementierungen in Joule und E unterstützen vollständig erstklassige Versprechen und Resolver.

Mehrere frühe Schauspielersprachen, einschließlich der ACT -Serie,^[19][20] unterstützte sowohl parallele Nachrichtenübergänge als auch pipelierte Nachrichtenverarbeitung, versprechen jedoch nicht Pipelining. (Obwohl es technisch möglich ist, die letzten dieser Merkmale in den ersten beiden zu implementieren, gibt es keine Beweise dafür, dass die ACT -Sprachen dies getan haben.)

Nach dem Jahr 2000 trat aufgrund ihrer Verwendung eine große Wiederbelebung des Interesse an Futures und Versprechen auf Empfänglichkeit von Benutzeroberflächen und in Web Entwicklung, aufgrund der Request -Reaktion Modell des Nachrichten-Passings. Mehrere Mainstream -Sprachen haben jetzt Sprachunterstützung für Futures und Versprechen, insbesondere von populärer durch Futuretask in Java 5 (angekündigt 2004)^[21] und die asynchron/wartet Konstruktionen in .NET 4.5 (angekündigt 2010, veröffentlicht 2012)^[22][23] weitgehend inspiriert von der Asynchrone Workflows aus#,^[24] das stammt von 2007.^[25] Dies wurde später von anderen Sprachen übernommen, insbesondere von Dart (2014).^[26] Python (2015),^[27] Hack (HHVM) und Entwürfe von ECMascript 7 (JavaScript), Scala und C ++ (2011).

Liste der Implementierungen

Einige Programmiersprachen unterstützen Futures, Versprechen, gleichzeitige Logikvariablen, Datenflussvariablen oder I-VARs, entweder durch direkte Sprachunterstützung oder in der Standardbibliothek.

Liste der Konzepte im Zusammenhang mit Futures und Versprechen durch Programmiersprache

• Abcl/f^[28]
• Alice Ml
• Ambienttalk (einschließlich erstklassiger Resolver und schreibgeschützter Versprechen)
• C ++, beginnen mit C ++ 11: std :: future und std :: versprechen
  • Zusammensetzung C ++
• Kristall (Programmiersprache)
• Pfeil (mit Zukunft/Abschluss Klassen^[29] und die Schlüsselwörter erwarten und Async^[26])
• ELM (Programmiersprache) über die Aufgabe Modul^[30]
• Glasgow Haskell (Nur I-Vars und M-Vars)
• Ausweis (Nur I-Vars und M-Vars)
• Io^[31]
• Java über java.util.concurrent.future oder java.util.concurrent.comPletableFuture
• JavaScript ab ECMaskript 2015,^[32] und über die Schlüsselwörter Async und erwarten Seit ECMascript 2017^[33]
• Klare (Nur Datenflow)
• Etwas LISPs
  • Clojure^[34]
  • Multilisp
• .NETZ über Aufgabes
  • C#, seit .NET Framework 4.5,^[22] über die Schlüsselwörter Async und erwarten^[23]
• Kotlin, jedoch kotlin.native.concurrent.future wird normalerweise nur beim Schreiben von Kotlin verwendet, das nativ laufen soll^[35]
• Nim
• Oxygen
• Oz Version 3^[36]
• Python gleichzeitig.Futurenseit 3.2,^[37] Wie vorgeschlagen von der Pep 3148und Python 3.5 fügte Async hinzu und warte auf^[38]
• R (Versprechen für die faule Bewertung, noch ein einzelner Thread)
• Schläger^[39]
• Raku^[40]
• Rost (Normalerweise durch erreicht durch .erwarten)^[41]
• Scala über Scala.Concurrent -Paket
• Planen
• Quietschen Smalltalk
• Strand
• Schnell (Nur über Bibliotheken von Drittanbietern)
• Visual Basic^{[Klarstellung erforderlich]} 11 (über die Schlüsselwörter Async und Erwarten)^[23]

Zu den Sprachen, die auch das Pipelining für das Versprechen unterstützen, gehören:

• E
• Joule

Liste der nicht standardmäßigen bibliotheksbasierten Implementierungen von Futures

• Zum Common Lisp:
  • Amsel^[42]
  • Eifrig future2^[43]
  • lparallel^[44]
  • PCALL^[45]
• Für c ++:
  • Boost Library^[46]
  • DLIB^[47]
  • Torheit^[48]
  • HPX ^[49]
  • Poco C ++ Bibliotheken (Aktive Ergebnisse)^[50]
  • Qt^[51]
  • Seestern^[52]
  • stlab^[53]
• Zum C# und andere .NETZ Sprachen: die Parallele Erweiterungen Bibliothek
• Zum Groovig: GPARS^[54]
• Zum JavaScript:
  • Cujo.js '^[55] wenn.js^[56] bietet Versprechen, die den Versprechen/a+ entsprechen^[57] 1.1 Spezifikation
  • Das Dojo -Toolkit Lieferungen Versprechen^[58] und Verdrehte Stilschieber
  • Mochikit^[59] inspiriert von Twisteds Aufschiebungen
  • JQuery's Aufgeschobenes Objekt basiert auf dem CommonJS Versprechen/a Entwurf.
  • Angularjs^[60]
  • Knoten-versprechen^[61]
  • Q, von Kris Kowal, entspricht den Versprechen/a+ 1,1^[62]
  • Rsvp.js, entspricht den Versprechen/a+ 1.1^[63]
  • Yui's^[64] Versprechen Sie Klasse^[65] entspricht der Versprechen/a+ 1.0 -Spezifikation.
  • Bluebird von Petka Antonov^[66]
  • Das Schließbibliothek's versprechen Das Paket entspricht der Versprechen/A+ -Schicht.
  • Sehen Versprechen/a+'s Liste für weitere Implementierungen basierend auf dem Versprechen/A+ -Design.
• Zum Java:
  • JDeferred bietet aufgeschobene API und Verhalten ähnliches wie JQuery.Deferred object^[67]
  • Parseq^[68] Bietet Aufgabenverständnis-API ideal für asynchrones Pipelining und Verzweigen, gepflegt von von LinkedIn
• Zum Lua:
  • Die Cques [1] Das Modul enthält eine Versprechen -API.
• Zum Ziel c: Mafuture,^[69][70] Rxpromise,^[71] OBJC-Collapsingfutures,^[72] Promisekit,^[73] OBJC-Verhütung,^[74] Oapromise,^[75]
• Zum Ocaml: Lazy Modul implementiert faule explizite Futures^[76]
• Zum Perl: Zukunft,^[77] Versprechen,^[78] Reflex,^[79] Versprechen :: es6,^[80] und Versprechen :: xs^[81]
• Zum Php: Reagieren/versprechen^[82]
• Zum Python:
  • Integrierte Implementierung^[83]
  • Pythonfuturen^[84]
  • Twisted's Aufschiebungen^[85]
• Zum R:
  • Zukunft implementiert eine erweiterbare zukünftige API mit faulen und eifrigen synchronen und (multicore oder verteilten) asynchronen Futures^[86][87]
• Zum Rubin:
  • Versprechen Sie Edelstein^[88]
  • Libuv Gem, implementiert Versprechen^[89]
  • Celluloid -Edelstein, implementiert Futures^[90]
  • Future-Ressource^[91]
• Zum Rost:
  • Futures-Rs^[92]
• Zum Scala:
  • Twitters Utilbibliothek^[93]
• Zum Schnell:
  • Asynchronen Framework, implementiert C#-Style Async/nicht blockierend erwarten^[94]
  • FutureKit,^[95] Implementiert eine Version für Apple GCD^[96]
  • Futurelib, Pure Swift 2 Bibliothek implementieren Sie Futures und Versprechen im Scala-Stil mit Stornierung im TPL-Stil^[97]
  • Aufgeschobene, reine Swift -Bibliothek inspiriert von Ocamls aufgeschobener^[98]
  • Brightfutures^[99]
  • SwiftCoroutine^[100]
• Zum Tcl: tcl-vomise^[101]

Coroutinen

Futures können in umgesetzt werden in Coroutinen^[27] oder Generatoren,^[102] Dies führt zu derselben Bewertungsstrategie (z. B. kooperativer Multitasking oder fauler Bewertung).

Kanäle

Futures können leicht in implementiert werden in Kanäle: Eine Zukunft ist ein Ein-Element-Kanal, und ein Versprechen ist ein Prozess, der an den Kanal sendet und die Zukunft erfüllt.^[103][104] Dies ermöglicht die Implementierung von Futures in gleichzeitigen Programmiersprachen mit Unterstützung für Kanäle wie CSP und gehen. Die daraus resultierenden Futures sind explizit, da sie durch Lesen vom Kanal und nicht nur die Bewertung zugänglich sind.

Siehe auch

• Faser (Informatik)
• Futex
• Pyramide des Untergangs (Programmierung), ein Design -Antipattern, der durch Versprechen vermieden wurde

Verweise

Externe Links

• Präsentation der Parallelitätsmuster an .. gegeben scaleconf
• Zukünftiger Wert und Versprechen Sie Pipelining Bei der Portland Muster Repository
• Einfach Faden mit Futures in Python