Ein Future (englisch Zukunft) oder 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. Ein Future ist meist das Ergebnis einses asynchronen Aufrufs einer Unterfunktion, das verwendet werden kann, 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 Papier von Henry Baker und Carl Hewitt vorgestellt. Automatisches "Pipelining" von Futures wurde in den 1980ern zwei mal unabhängig von einander erfunden, einmal bei Project Xanadu (circa 1989) und von Barbara Liskov (1988).
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 Implamantation kann die Wartezeit beschränkt werden (Timeout), und es kann zusätzliche Funktionen zur abfrage des Aktuellen status geben.
Sind futures direkt in die Programmiersprache integriert, so ist häufig nur ein asynchroner Zuweisungsoperator definiert, zum Beispiel x @= Ausdruck in Flow Java. Diese bedeutet starte einen Prozess zum Berechnen des Ausdrucks, die rechts des Operators steht, und weise der Variable x link vom Operator ein Future für das Egebnis zu. Wird nun später auf die Variable x zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.
Programmiersprachen und Programmbibliotheken, die Futures oder Promises understützen:
Beispiel
Der folgende Pseudocode zeigt die Verwendung von Futures mittels dem asynchronen Zuweisungsoperator @=.
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.
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 Periferiegeräte verbringen.
Literatur
- Henry 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. May 1981.
- Henry Lieberman. A Preview of Act 1 MIT AI memo 625. June 1981.
Web Links
- PromisePipelining auf dem C2 wiki (englisch)