imported>InkoBot: Bot: Ersetze hartkodierte Farbangabe durch Farbklasse

2025-03-06T17:44:16Z

Bot: Ersetze hartkodierte Farbangabe durch Farbklasse

Neue Seite

Ein '''Future''' ([[Englische Sprache|engl.]] ‚Zukunft‘) oder ein '''Promise''' (engl. ‚Versprechen‘) bezeichnet in der [[Programmierung]] einen Platzhalter (''[[Stellvertreter (Entwurfsmuster)|Proxy]]'') für ein Ergebnis, das noch nicht bekannt ist, meist weil seine Berechnung noch nicht abgeschlossen ist.

Ein Future ist meist das Ergebnis eines [[Asynchrone Kommunikation|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 [[Parallele Programmierung|Parallelisierung]] [[Nebenläufigkeit|nebenläufiger]] [[Prozess (Informatik)|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 des Futures 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 (Netzwerktechnik)|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 [[Zuweisung]]soperator'' definiert, zum Beispiel x @= ''Ausdruck'' in ''[[Flow Java]]'', einer an [[Java (Programmiersprache)|Java]] angelehnten experimentellen Programmiersprache. Dies bedeutet: Starte einen Prozess zum Berechnen des Ausdrucks, der rechts des Operators steht, und weise der Variable x ein 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 [[Programmbibliothek]]en, die ''Futures'' oder ''Promises'' unterstützen sind [[CORBA]] (mit ''Asynchronous Method Invocation (AMI)''), und – ab Version 5 – [[Java (Programmiersprache)|Java]] mittels ''Concurrency Utilities'', einer Klassenbibliothek für Nebenläufigkeit. [[JavaScript]] stellt diese Konstrukte seit [[ECMAScript]] 6 bereit (wenngleich derzeit noch in eingeschränkter Form.)<ref>{{Internetquelle |url=https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise |titel=Promise |werk=MDN |hrsg=Mozilla Foundation |zugriff=2014-10-31 |sprache=en}}</ref> [[Rust (Programmiersprache)|Rust]] stellt ebenfalls ''Futures'' zur Verfügung. Auch für [[C++]] stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen ist [[Boost (C++-Bibliothek)|Boost]]. Im Standard [[C++11]] sind Nebenläufigkeit und Futures ebenfalls in der [[C++-Standardbibliothek|Standardbibliothek]] verfügbar. Weitere Programmiersprachen mit Unterstützung für ''Futures'' und ''Promises'' sind [[io (Programmiersprache)|Io]], [[Oz (Programmiersprache)|Oz]], [[Scheme]], [[Smalltalk (Programmiersprache)|Smalltalk]] und [[Scala (Programmiersprache)|Scala]].

In [[C-Sharp|C# 5.0]] und [[Visual Basic .NET|Visual Basic 2013]] werden Futures über async und await implizit verwendet.<ref>{{Internetquelle |url=http://msdn.microsoft.com/en-us/library/windows/apps/hh464924.aspx |titel=Asynchronous programming (Windows Store apps) |werk=MSDN |hrsg=Microsoft |zugriff=2014-02-22 |sprache=en}}</ref> Eine entsprechende Future-Klasse ist hierbei in den [[Parallel Extensions]] definiert und kann somit auch in älteren Versionen und anderen Programmiersprachen verwendet werden. Eine solche kann bei Bedarf allerdings auch selbst implementiert werden.<ref>{{Internetquelle |url=http://msdn.microsoft.com/en-us/library/ff963556.aspx |titel=Futures |werk=MSDN, Parallel Programming with Microsoft .NET |sprache=en |hrsg=Microsoft |zugriff=2014-02-22}}</ref><ref>{{Internetquelle |url=http://dvanderboom.wordpress.com/2008/07/03/concurrency-with-futures/ |titel=Concurrency & Coordination With Futures in C# |autor=Dan Vanderboom |datum=2008-07-03 |werk=Critical Development |zugriff=2014-02-22 |sprache=en}}</ref><ref>{{Internetquelle |url=https://bitbucket.org/mattkotsenas/c-promises/overview |werk=BitBucket |autor=Matt Kotsenas at. al. |zugriff=2014-02-23 |titel=C# Promises |sprache=en}}</ref>

== Aufbau ==
Ein Future ist eine [[Monade (Informatik)|Monade]] mit einem zugehörigen [[Resolver (Informatik)|Resolver]], welcher dem Future einen Wert zuweist. Das Future kann sich in einem von drei Zuständen befinden:
* erfüllt (englisch: ''{{lang|en|promise kept}}'')
* gebrochen (englisch: ''{{lang|en|promise broken}}'')
* wartend (englisch: ''{{lang|en|promise pending}}'')
Wenn der Wert vom Resolver zugewiesen und damit bekannt ist, generiert das Future ein [[Ereignis (Programmierung)|Ereignis]] für welche [[Rückruffunktion]]en registriert werden.

== 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:

{| class="wikitable"
|-
! Haupt-Thread
! X-Thread
! Y-Thread
|-
| ''starte'' berechneX()
| class="hintergrundfarbe-basis" |  
| class="hintergrundfarbe-basis" rowspan="2" |  
|-
| ''starte'' berechneY()
| rowspan="3" style="vertical-align:center;" | berechneX()
|-
| berechneZ()
| rowspan="3" style="vertical-align:center;" | berechneY()
|-
| class="hintergrundfarbe-basis" rowspan="2" | ''warte'' auf x und y
|-
| rowspan="2" class="hintergrundfarbe-basis" |  
|-
| berechne ergebnis
| class="hintergrundfarbe-basis" |  
|}

Die Aufteilung der Berechnung auf mehrere [[Thread (Informatik)|Threads]] kann Berechnungen deutlich beschleunigen, wenn mehrere [[Hauptprozessor]]en (oder [[Prozessorkern]]e) zur Verfügung stehen, oder wenn die einzelnen Berechnungen den Hauptprozessor nicht auslasten, weil sie etwa viel Zeit mit dem Warten auf [[Peripheriegerät]]e 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 ==
* [http://c2.com/cgi/wiki?PromisePipelining PromisePipelining] auf dem [http://c2.com/cgi/wiki?FrontPage C2 wiki] (englisch)
* {{Internetquelle |url=http://channel9.msdn.com/Shows/Going+Deep/Hewitt-Meijer-and-Szyperski-The-Actor-Model-everything-you-wanted-to-know-but-were-afraid-to-ask |titel=Hewitt, Meijer and Szyperski: The Actor Model (everything you wanted to know, but were afraid to ask) |datum=2012-04-09 |autor=[[Carl Hewitt]], [[Erik Meijer (Informatiker)|Erik Meijer]], [[Clemens Szyperski]] |zugriff=2014-02-22 |sprache=en |hrsg=Microsoft |werk=Channel 9}}
* {{YouTube | id=w9hHHvhZ_HY | title=Vortrag von Mark S. Miller: ''Secure Distributed Programming with Object-capabilities in JavaScript''}} (englisch)
* {{YouTube | id=oBqeDYETXME | title=Vortrag von Mark S. Miller: ''Bringing Object-orientation to Security Programming''}} (englisch)

== Einzelnachweise ==
<references />

[[Kategorie:Parallelverarbeitung]]
[[Kategorie:Entwurfsmuster]]

Future (Programmierung) - Versionsgeschichte

imported>InkoBot: Bot: Ersetze hartkodierte Farbangabe durch Farbklasse