EinFuture (engl. ‚Zukunft‘) oder einPromise (engl. ‚Versprechen‘) bezeichnet in derProgrammierung einen Platzhalter (Proxy) für ein Ergebnis, das noch nicht bekannt ist, meist weil seine Berechnung noch nicht abgeschlossen ist.
Ein Future ist meist das Ergebnis einesasynchronen Aufrufs einer Funktion oder einer Methode und kann verwendet werden, um auf das Ergebnis zuzugreifen, sobald es verfügbar ist. Diese Art der Programmierung erlaubt eine weitgehend transparenteParallelisierungnebenläufigerProzesse. Das Konzept der Futures wurde 1977 in einem Artikel vonHenry G. Baker undCarl Hewitt vorgestellt.
Eine zentrale Idee der Programmierung mit Futures ist, dass Futures als Argumente an andere Prozeduraufrufe weitergereicht werden können. Die Auswertung dieses Aufrufs kann dann schon beginnen, bevor das Ergebnis des Futures selbst verfügbar ist. Das erlaubt ein maximales Maß an Parallelismus. Erfolgt der neue Aufruf wiederum asynchron, so spricht man auch vonPipelining der Futures. Pipelining kann insbesondere in verteilten Anwendungen benutzt werden, um die Latenzzeiten vonInterprozesskommunikation zu minimieren.
Futures sind ein Konstrukt zur asynchronenInterprozesskommunikation. Konzeptionell bietet ein Future eineget- oderjoin-Funktion, die so lange blockiert, bis das Ergebnis vorliegt, und dieses dann zurückliefert. Je nach Implementierung kann die Wartezeit mittelsTimeout beschränkt werden oder durch zusätzliche Funktionen eine Abfrage des aktuellen Status erfolgen.
Sind Futures direkt in dieProgrammiersprache integriert, so ist häufig nur einasynchronerZuweisungsoperator definiert, zum Beispielx @=Ausdruck inFlow Java, einer anJava angelehnten experimentellen Programmiersprache. Dies bedeutet: Starte einen Prozess zum Berechnen des Ausdrucks, der rechts des Operators steht, und weise der Variablex ein Future für das Ergebnis zu. Wird danach auf die Variablex zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.
Programmiersprachen undProgrammbibliotheken, dieFutures oderPromises unterstützen sindCORBA (mitAsynchronous Method Invocation (AMI)), und – ab Version 5 –Java mittelsConcurrency Utilities, einer Klassenbibliothek für Nebenläufigkeit.JavaScript stellt diese Konstrukte seitECMAScript 6 bereit (wenngleich derzeit noch in eingeschränkter Form.)[1]Rust stellt ebenfallsFutures zur Verfügung. Auch fürC++ stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen istBoost. Im StandardC++11 sind Nebenläufigkeit und Futures ebenfalls in derStandardbibliothek verfügbar. Weitere Programmiersprachen mit Unterstützung fürFutures undPromises sindIo,Oz,Scheme,Smalltalk undScala.
InC# 5.0 undVisual Basic 2013 werden Futures über async und await implizit verwendet.[2] Eine entsprechende Future-Klasse ist hierbei in denParallel Extensions definiert und kann somit auch in älteren Versionen und anderen Programmiersprachen verwendet werden. Eine solche kann bei Bedarf allerdings auch selbst implementiert werden.[3][4][5]
Ein Future ist eineMonade mit einem zugehörigenResolver, welcher dem Future einen Wert zuweist. Das Future kann sich in einem von drei Zuständen befinden:
Wenn der Wert vom Resolver zugewiesen und damit bekannt ist, generiert das Future einEreignis für welcheRückruffunktionen registriert werden.
Der folgendePseudocode zeigt die Verwendung von Futures mittels des asynchronen Zuweisungsoperators@=.
var x @= berechneX();// Beginne Berechnung von xvar y @= berechneY();// Beginne Berechnung von y
var z = berechneZ();// Vollständige Berechnung von z
var ergebnis= x + y + z;// Benutze x, y und z.// Hier muss dann eventuell auf die Berechnung// von x und y gewartet werden.
Daraus ergibt sich folgende Parallelisierung:
| Haupt-Thread | X-Thread | Y-Thread |
|---|---|---|
| starte berechneX() | ||
| starte berechneY() | berechneX() | |
| berechneZ() | berechneY() | |
| warte auf x und y | ||
| berechne ergebnis |
Die Aufteilung der Berechnung auf mehrereThreads kann Berechnungen deutlich beschleunigen, wenn mehrereHauptprozessoren (oderProzessorkerne) zur Verfügung stehen, oder wenn die einzelnen Berechnungen den Hauptprozessor nicht auslasten, weil sie etwa viel Zeit mit dem Warten aufPeripheriegeräte verbringen.