Future (Programmierung) - Versionsgeschichte

InkoBot: Bot: Ersetze hartkodierte Farbangabe durch Farbklasse

2025-03-06T17:44:16Z

Bot: Ersetze hartkodierte Farbangabe durch Farbklasse

← Nächstältere Version		Version vom 6. März 2025, 18:44 Uhr
Zeile 40:		Zeile 40:
	! X-Thread		! X-Thread
	! Y-Thread		! Y-Thread
	\|---		\|-
	\| ''starte'' berechneX()		\| ''starte'' berechneX()
	\| ~~style~~="~~background~~-~~color:white~~" \|		\| class="hintergrundfarbe-basis" \|
	\| ~~style~~="~~background~~-~~color:white~~" rowspan="2" \|		\| class="hintergrundfarbe-basis" rowspan="2" \|
	\|---		\|-
	\| ''starte'' berechneY()		\| ''starte'' berechneY()
	\| rowspan="3" ~~valign~~="center" \| berechneX()		\| rowspan="3" style="vertical-align:center;" \| berechneX()
	\|---		\|-
	\| berechneZ()		\| berechneZ()
	\| rowspan="3" ~~valign~~="center" \| berechneY()		\| rowspan="3" style="vertical-align:center;" \| berechneY()
	\|---		\|-
	\| ~~style~~="~~background~~-~~color:white~~" rowspan="2" \| ''warte'' auf x und y		\| class="hintergrundfarbe-basis" rowspan="2" \| ''warte'' auf x und y
	\|---		\|-
	\| rowspan="2" ~~style~~="~~background~~-~~color:white~~" \|		\| rowspan="2" class="hintergrundfarbe-basis" \|
	\|---		\|-
	\| berechne ergebnis		\| berechne ergebnis
	\| ~~style~~="~~background~~-~~color:white~~" \|		\| class="hintergrundfarbe-basis" \|
	\|}		\|}

2A02:908:1087:59A0:0:0:0:80CB: Rust als Beispiel für Programmiersprachen, die von Haus aus Futures unterstützen

2022-09-11T18:25:44Z

Rust als Beispiel für Programmiersprachen, die von Haus aus Futures unterstützen

← Nächstältere Version		Version vom 11. September 2022, 19:25 Uhr
Zeile 10:		Zeile 10:
	Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <span style="font-family:monospace;">x @= ''Ausdruck''</span> 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 <span style="font-family:monospace;">x</span> ein Future für das Ergebnis zu. Wird danach auf die Variable <span style="font-family:monospace;">x</span> zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.		Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <span style="font-family:monospace;">x @= ''Ausdruck''</span> 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 <span style="font-family:monospace;">x</span> ein Future für das Ergebnis zu. Wird danach auf die Variable <span style="font-family:monospace;">x</span> 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> 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]].		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>		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>

TaxonBot: Bot: Überarbeitung veralteter Syntax / HTML-Validierung

2021-04-10T11:51:02Z

Bot: Überarbeitung veralteter Syntax / HTML-Validierung

← Nächstältere Version		Version vom 10. April 2021, 12:51 Uhr
Zeile 8:		Zeile 8:
	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.		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 <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.		Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <span style="font-family:monospace;">x @= ''Ausdruck''</span> 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 <span style="font-family:monospace;">x</span> ein Future für das Ergebnis zu. Wird danach auf die Variable <span style="font-family:monospace;">x</span> 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> 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]].		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> 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]].
Zeile 22:		Zeile 22:

	== Beispiel ==		== Beispiel ==
	Der folgende [[Pseudocode]] zeigt die Verwendung von Futures mittels des asynchronen Zuweisungsoperators <tt>@=</tt>.		Der folgende [[Pseudocode]] zeigt die Verwendung von Futures mittels des asynchronen Zuweisungsoperators <span style="font-family:monospace;">@=</span>.

	var x @= berechneX(); ''// Beginne Berechnung von x''		var x @= berechneX(); ''// Beginne Berechnung von x''

Joschi71: Die letzte Textänderung von 90.166.223.151 wurde verworfen. "Funktion" hier im Sinne von: wozu verwendet, nicht im Sinne von Progammiersprache.

2019-06-14T10:48:47Z

Die letzte Textänderung von 90.166.223.151 wurde verworfen. "Funktion" hier im Sinne von: wozu verwendet, nicht im Sinne von Progammiersprache.

← Nächstältere Version		Version vom 14. Juni 2019, 11:48 Uhr
Zeile 5:		Zeile 5:
	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.		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.

	== ~~Rückruf-~~Funktion ==		== 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.		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.

90.166.223.151: /* Funktion */

2019-06-14T08:02:05Z

Funktion

← Nächstältere Version		Version vom 14. Juni 2019, 09:02 Uhr
Zeile 5:		Zeile 5:
	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.		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 ==		== Rückruf-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.		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.

Tea2min: /* Funktion */ Reihenfolge etwas umgestellt. C++11 ist nicht mehr neu, seither wurden C++14 und C++17 veröffentlicht, und C++20 ist in Arbeit.

2018-11-05T08:53:52Z

Funktion: Reihenfolge etwas umgestellt. C++11 ist nicht mehr neu, seither wurden C++14 und C++17 veröffentlicht, und C++20 ist in Arbeit.

← Nächstältere Version		Version vom 5. November 2018, 09:53 Uhr
Zeile 10:		Zeile 10:
	Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.		Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> 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)''), ~~[[io (Programmiersprache)\|Io]], [[Oz (Programmiersprache)\|Oz]], [[Scheme]], [[Smalltalk (Programmiersprache)\|Smalltalk]], [[Scala_(Programmiersprache)\|Scala]]~~ 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>. Auch für C++ stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen ist [[Boost (C++-Bibliothek)\|Boost]]. Im ~~neuen~~ Standard [[C++11]] sind Nebenläufigkeit und Futures ebenfalls in der [[C++-Standardbibliothek\|Standardbibliothek]] verfügbar.		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> 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>		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>

84.115.58.150: Einfügen Scala als weitere Programmiersprache

2018-09-24T06:51:50Z

Einfügen Scala als weitere Programmiersprache

← Nächstältere Version		Version vom 24. September 2018, 07:51 Uhr
Zeile 10:		Zeile 10:
	Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.		Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> 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)''), [[io (Programmiersprache)\|Io]], [[Oz (Programmiersprache)\|Oz]], [[Scheme]], [[Smalltalk (Programmiersprache)\|Smalltalk]] 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>. Auch für C++ stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen ist [[Boost (C++-Bibliothek)\|Boost]]. Im neuen Standard [[C++11]] sind Nebenläufigkeit und Futures ebenfalls in der [[C++-Standardbibliothek\|Standardbibliothek]] verfügbar.		Programmiersprachen und [[Programmbibliothek]]en, die ''Futures'' oder ''Promises'' unterstützen sind [[CORBA]] (mit ''Asynchronous Method Invocation (AMI)''), [[io (Programmiersprache)\|Io]], [[Oz (Programmiersprache)\|Oz]], [[Scheme]], [[Smalltalk (Programmiersprache)\|Smalltalk]], [[Scala_(Programmiersprache)\|Scala]] 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>. Auch für C++ stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen ist [[Boost (C++-Bibliothek)\|Boost]]. Im neuen Standard [[C++11]] sind Nebenläufigkeit und Futures ebenfalls in der [[C++-Standardbibliothek\|Standardbibliothek]] verfügbar.

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

NiTenIchiRyu: /* Funktion */

2018-04-03T09:16:56Z

Funktion

← Nächstältere Version		Version vom 3. April 2018, 10:16 Uhr
Zeile 6:		Zeile 6:

	== Funktion ==		== 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.		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 <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.		Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.

Trustable: Kleinigkeiten verbessert

2017-04-13T17:33:58Z

Kleinigkeiten verbessert

Crazy1880: Doppel-Ref-TAG entfernt

2016-12-12T07:58:08Z

Doppel-Ref-TAG entfernt

← Nächstältere Version		Version vom 12. Dezember 2016, 08:58 Uhr
Zeile 1:		Zeile 1:
	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''' ([[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 (Computer)\|Prozesse]]. Das Konzept der Futures wurde 1977 in einem Artikel von [[Henry G. Baker]] und [[Carl Hewitt]] vorgestellt.		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 (Computer)\|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.		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.
Zeile 10:		Zeile 10:
	Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.		Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> 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)''), [[io (Programmiersprache)\|Io]], [[Oz (Programmiersprache)\|Oz]], [[Scheme]], [[Smalltalk (Programmiersprache)\|Smalltalk]] und – seit 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>. Auch für C++ stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen ist [[Boost (C++-Bibliothek)\|Boost]]. Im neuen Standard [[C++11]] sind Nebenläufigkeit und Futures ebenfalls in der [[C++-Standardbibliothek\|Standardbibliothek]] verfügbar.		Programmiersprachen und [[Programmbibliothek]]en, die ''Futures'' oder ''Promises'' unterstützen sind [[CORBA]] (mit ''Asynchronous Method Invocation (AMI)''), [[io (Programmiersprache)\|Io]], [[Oz (Programmiersprache)\|Oz]], [[Scheme]], [[Smalltalk (Programmiersprache)\|Smalltalk]] und – seit 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>. Auch für C++ stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen ist [[Boost (C++-Bibliothek)\|Boost]]. Im neuen Standard [[C++11]] sind Nebenläufigkeit und Futures ebenfalls in der [[C++-Standardbibliothek\|Standardbibliothek]] verfügbar.

	In [[CSharp\|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>		In [[CSharp\|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 ==		== 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:		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}}'')		* erfüllt (englisch: ''{{lang\|en\|promise kept}}'')
	* gebrochen (englisch: ''{{lang\|en\|promise broken}}'')		* gebrochen (englisch: ''{{lang\|en\|promise broken}}'')
Zeile 26:		Zeile 26:
	var x @= berechneX(); ''// Beginne Berechnung von x''		var x @= berechneX(); ''// Beginne Berechnung von x''
	var y @= berechneY(); ''// Beginne Berechnung von y''		var y @= berechneY(); ''// Beginne Berechnung von y''


	var z = berechneZ(); ''// Vollständige Berechnung von z''		var z = berechneZ(); ''// Vollständige Berechnung von z''


	var ergebnis= x + y + z; ''// Benutze x, y und z.''		var ergebnis= x + y + z; ''// Benutze x, y und z.''
	''// Hier muss dann eventuell auf die Berechnung''		''// Hier muss dann eventuell auf die Berechnung''
Zeile 35:		Zeile 35:
	Daraus ergibt sich folgende Parallelisierung:		Daraus ergibt sich folgende Parallelisierung:

	{\| class="~~prettytable~~"		{\| class="wikitable"
			\|-
	! Haupt-Thread		! Haupt-Thread
	! X-Thread		! X-Thread
Zeile 58:		Zeile 59:
	\|}		\|}

	Die Aufteilung der Berechnung auf mehrere [[Thread (Informatik)\|~~Thread~~]]s 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.		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 ==		== Literatur ==
Zeile 67:		Zeile 68:
	== Weblinks ==		== Weblinks ==
	* [http://c2.com/cgi/wiki?PromisePipelining PromisePipelining] auf dem [http://c2.com/cgi/wiki?FrontPage C2 wiki] (englisch)		* [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}}		* {{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}}
	* {{Internetquelle\|url=https://www.youtube.com/watch?v=w9hHHvhZ_HY\|titel=Secure Distributed Programming with Object-capabilities in JavaScript\|autor=Mark S. Miller\|hrsg=Software Languages Lab\|werk=YouTube\|sprache=en\|zugriff=2014-02-22\|datum=2011-10-31}}		* {{Internetquelle \|url=https://www.youtube.com/watch?v=w9hHHvhZ_HY \|titel=Secure Distributed Programming with Object-capabilities in JavaScript \|autor=Mark S. Miller \|hrsg=Software Languages Lab \|werk=YouTube \|sprache=en \|zugriff=2014-02-22 \|datum=2011-10-31}}
	* {{Internetquelle\|url=https://www.youtube.com/watch?v=oBqeDYETXME\|titel=Bringing Object-orientation to Security Programming\|autor=Mark S. Miller\|hrsg=Software Languages Lab\|werk=YouTube\|sprache=en\|zugriff=2014-02-22\|datum=2011-10-31}}		* {{Internetquelle \|url=https://www.youtube.com/watch?v=oBqeDYETXME \|titel=Bringing Object-orientation to Security Programming \|autor=Mark S. Miller \|hrsg=Software Languages Lab \|werk=YouTube \|sprache=en \|zugriff=2014-02-22 \|datum=2011-10-31}}

	== ~~Quellen~~ ==		== Einzelnachweise ==
	<references />		<references />

	== Einzelnachweise ==
	<references></references>

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

← Nächstältere Version		Version vom 11. September 2022, 19:25 Uhr
Zeile 10:		Zeile 10:
	Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <span style="font-family:monospace;">x @= ''Ausdruck''</span> 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 <span style="font-family:monospace;">x</span> ein Future für das Ergebnis zu. Wird danach auf die Variable <span style="font-family:monospace;">x</span> zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.		Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <span style="font-family:monospace;">x @= ''Ausdruck''</span> 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 <span style="font-family:monospace;">x</span> ein Future für das Ergebnis zu. Wird danach auf die Variable <span style="font-family:monospace;">x</span> 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> 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]].		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>		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>

← Nächstältere Version		Version vom 5. November 2018, 09:53 Uhr
Zeile 10:		Zeile 10:
	Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.		Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> 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)''), ~~[[io (Programmiersprache)\|Io]], [[Oz (Programmiersprache)\|Oz]], [[Scheme]], [[Smalltalk (Programmiersprache)\|Smalltalk]], [[Scala_(Programmiersprache)\|Scala]]~~ 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>. Auch für C++ stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen ist [[Boost (C++-Bibliothek)\|Boost]]. Im ~~neuen~~ Standard [[C++11]] sind Nebenläufigkeit und Futures ebenfalls in der [[C++-Standardbibliothek\|Standardbibliothek]] verfügbar.		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> 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>		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>

← Nächstältere Version		Version vom 24. September 2018, 07:51 Uhr
Zeile 10:		Zeile 10:
	Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.		Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> 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)''), [[io (Programmiersprache)\|Io]], [[Oz (Programmiersprache)\|Oz]], [[Scheme]], [[Smalltalk (Programmiersprache)\|Smalltalk]] 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>. Auch für C++ stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen ist [[Boost (C++-Bibliothek)\|Boost]]. Im neuen Standard [[C++11]] sind Nebenläufigkeit und Futures ebenfalls in der [[C++-Standardbibliothek\|Standardbibliothek]] verfügbar.		Programmiersprachen und [[Programmbibliothek]]en, die ''Futures'' oder ''Promises'' unterstützen sind [[CORBA]] (mit ''Asynchronous Method Invocation (AMI)''), [[io (Programmiersprache)\|Io]], [[Oz (Programmiersprache)\|Oz]], [[Scheme]], [[Smalltalk (Programmiersprache)\|Smalltalk]], [[Scala_(Programmiersprache)\|Scala]] 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>. Auch für C++ stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen ist [[Boost (C++-Bibliothek)\|Boost]]. Im neuen Standard [[C++11]] sind Nebenläufigkeit und Futures ebenfalls in der [[C++-Standardbibliothek\|Standardbibliothek]] verfügbar.

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

← Nächstältere Version		Version vom 13. April 2017, 18:33 Uhr
Zeile 1:		Zeile 1:
	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''' ([[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 (~~Computer~~)\|Prozesse]]. Das Konzept der Futures wurde 1977 in einem Artikel von [[Henry G. Baker]] und [[Carl Hewitt]] vorgestellt.		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.		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.
Zeile 10:		Zeile 10:
	Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> zugegriffen, so wird an dieser Stelle so lange gewartet, bis das Ergebnis vorliegt.		Sind Futures direkt in die [[Programmiersprache]] integriert, so ist häufig nur ein ''asynchroner [[Zuweisung]]soperator'' definiert, zum Beispiel <tt>x @= ''Ausdruck''</tt> 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 <tt>x</tt> ein Future für das Ergebnis zu. Wird danach auf die Variable <tt>x</tt> 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)''), [[io (Programmiersprache)\|Io]], [[Oz (Programmiersprache)\|Oz]], [[Scheme]], [[Smalltalk (Programmiersprache)\|Smalltalk]] und – ~~seit~~ 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>. Auch für C++ stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen ist [[Boost (C++-Bibliothek)\|Boost]]. Im neuen Standard [[C++11]] sind Nebenläufigkeit und Futures ebenfalls in der [[C++-Standardbibliothek\|Standardbibliothek]] verfügbar.		Programmiersprachen und [[Programmbibliothek]]en, die ''Futures'' oder ''Promises'' unterstützen sind [[CORBA]] (mit ''Asynchronous Method Invocation (AMI)''), [[io (Programmiersprache)\|Io]], [[Oz (Programmiersprache)\|Oz]], [[Scheme]], [[Smalltalk (Programmiersprache)\|Smalltalk]] 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>. Auch für C++ stehen verschiedene Bibliotheken zur Verfügung, die wohl bekannteste von ihnen ist [[Boost (C++-Bibliothek)\|Boost]]. Im neuen Standard [[C++11]] sind Nebenläufigkeit und Futures ebenfalls in der [[C++-Standardbibliothek\|Standardbibliothek]] verfügbar.

	In [[~~CSharp~~\|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>		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 ==		== Aufbau ==
Zeile 24:		Zeile 24:
	Der folgende [[Pseudocode]] zeigt die Verwendung von Futures mittels des asynchronen Zuweisungsoperators <tt>@=</tt>.		Der folgende [[Pseudocode]] zeigt die Verwendung von Futures mittels des asynchronen Zuweisungsoperators <tt>@=</tt>.

	var x @= berechneX(); ''// Beginne Berechnung von x''		var x @= berechneX(); ''// Beginne Berechnung von x''
	var y @= berechneY(); ''// Beginne Berechnung von y''		var y @= berechneY(); ''// Beginne Berechnung von y''

	var z = berechneZ(); ''// Vollständige Berechnung von z''		var z = berechneZ(); ''// Vollständige Berechnung von z''

	var ergebnis= x + y + z; ''// Benutze x, y und z.''		var ergebnis= x + y + z; ''// Benutze x, y und z.''
	''// Hier muss dann eventuell auf die Berechnung''		''// Hier muss dann eventuell auf die Berechnung''
	''// von x und y gewartet werden.''		''// von x und y gewartet werden.''

	Daraus ergibt sich folgende Parallelisierung:		Daraus ergibt sich folgende Parallelisierung:
Zeile 69:		Zeile 69:
	* [http://c2.com/cgi/wiki?PromisePipelining PromisePipelining] auf dem [http://c2.com/cgi/wiki?FrontPage C2 wiki] (englisch)		* [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}}		* {{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}}
	* {{~~Internetquelle~~ \|~~url=https://www.youtube.com/watch?v~~=w9hHHvhZ_HY \|~~titel~~=Secure Distributed Programming with Object-capabilities in JavaScript ~~\|autor=Mark S. Miller \|hrsg=Software Languages Lab \|werk=YouTube \|sprache=en \|zugriff=2014-02-22 \|datum=2011-10-31~~}}		* {{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)
	* {{Internetquelle \|url=https://www.youtube.com/watch?v=oBqeDYETXME \|titel=Bringing Object-orientation to Security Programming \|autor=Mark S. Miller \|hrsg=Software Languages Lab \|werk=YouTube \|sprache=en \|zugriff=2014-02-22 \|datum=2011-10-31}}

	== Einzelnachweise ==		== Einzelnachweise ==