Future (Programmierung)

Eine Future (englisch Zukunft) oder ein Promise (englisch Versprechen) bezeichnet in der Programmierung einen Platzhalter (Proxy) für ein Ergebnis, das noch nicht bekannt ist, meist weil seine Berechnung noch nicht abgeschlossen ist.

Eine Future ist meist das Ergebnis eines asynchronen 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 transparente Parallelisierung nebenläufiger Prozesse. Das Konzept der Futures wurde 1977 in einem Artikel von Henry G. Baker und Carl 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 der Future selbst verfügbar ist. Das erlaubt ein maximales Maß an Parallelismus. Erfolgt der neue Aufruf wiederum asynchron, so spricht man auch von Pipelining der Futures. Pipelining kann insbesondere in verteilten Anwendungen benutzt werden, um die Latenzzeiten von Interprozesskommunikation zu minimieren.

Funktion

Futures sind ein Konstrukt zur asynchronen Interprozesskommunikation. Konzeptionell bietet ein Future eine get- oder join-Funktion, die so lange blockiert, bis das Ergebnis vorliegt, und dieses dann zurückliefert. Je nach Implementierung kann die Wartezeit mittels Timeout beschränkt werden oder durch zusätzliche Funktionen eine Abfrage des aktuellen Status erfolgen.

Sind Futures direkt in die Programmiersprache integriert, so ist häufig nur ein asynchroner Zuweisungsoperator definiert, zum Beispiel x @= Ausdruck in Flow Java, einer an Java angelehnten experimentellen Programmiersprache. Dies bedeutet: Starte einen Prozess zum Berechnen des Ausdrucks, der rechts des Operators steht, und weise der Variable x eine Future für das Ergebnis zu. Wird danach auf die Variable x zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.

Programmiersprachen und Programmbibliotheken, die Futures oder Promises unterstützen sind CORBA (mit Asynchronous Method Invocation (AMI)), io, Oz, Scheme, Smalltalk und – seit Version 5 – Java mittels Concurrency Utilities, einer Klassenbibliothek für Nebenläufigkeit. Auch für C++ stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen ist Boost.

Beispiel

Der folgende Pseudocode zeigt die Verwendung von Futures mittels des asynchronen Zuweisungsoperators @=.

var x @= berechneX();      // Beginne Berechnung von x
var 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 mehrere Threads kann Berechnungen deutlich beschleunigen, wenn mehrere Hauptprozessoren (oder Prozessorkerne) zur Verfügung stehen, oder wenn die einzelnen Berechnungen den Hauptprozessor nicht auslasten, weil sie etwa viel Zeit mit dem Warten auf Peripheriegeräte verbringen.

Literatur

• Henry G. Baker and Carl Hewitt: The Incremental Garbage Collection of Processes. Proceeding of the Symposium on Artificial Intelligence Programming Languages. SIGPLAN Notices 12. August 1977.
• Henry Lieberman: Thinking About Lots of Things at Once without Getting Confused: Parallelism in Act 1. MIT AI memo 626. Mai 1981.
• Henry Lieberman: A Preview of Act 1. MIT AI memo 625. Juni 1981.

Weblinks

• PromisePipelining auf dem C2 wiki (englisch)