<future> -Funktionen

async
future_category
make_error_code
make_error_condition
swap|

async

Stellt einen asynchronen Anbieter dar.

template <class Fn, class... ArgTypes>
future<typename result_of<Fn(ArgTypes...)>::type>
    async(Fn&& fn, ArgTypes&&... args);

template <class Fn, class... ArgTypes>
future<typename result_of<Fn(ArgTypes...)>::type>
    async(launch policy, Fn&& fn, ArgTypes&&... args);

Parameter

Richtlinie
Ein launch-Wert.

Hinweise

Definitionen von Abkürzungen:

Abkürzung	Beschreibung
dfn	Das Ergebnis des Aufrufs von decay_copy(forward<Fn>(fn)).
dargs	Die Ergebnisse des Aufrufs von decay_copy(forward<ArgsTypes>(args...)).
Ty	Der result_of<Fn(ArgTypes...)>::type-Typ.

Die erste Vorlagenfunktion gibt async(launch::any, fn, args...) zurück.

Die zweite Funktion gibt ein future<Ty> Objekt zurück, dessen zugeordneter asynchroner Zustand ein Ergebnis zusammen mit den Werten dfn und dargs einem Threadobjekt enthält, um einen separaten Thread der Ausführung zu verwalten.

Sofern es sich nicht decay<Fn>::type um einen anderen Typ als "Start" handelt, nimmt die zweite Funktion nicht an der Überladungsauflösung teil.

Der C++-Standard gibt an, dass die Funktion bei "launch::async" einen neuen Thread erstellt. Die Microsoft-Implementierung ist derzeit jedoch nicht konform. Er ruft seine Threads aus dem Windows ThreadPool ab, die in einigen Fällen einen recycelten Thread anstelle eines neuen Threads bereitstellen können. Dies bedeutet, dass die launch::async Richtlinie als launch::async|launch::deferredimplementiert wird. Eine weitere Auswirkung der ThreadPool-basierten Implementierung besteht darin, dass keine Garantie dafür besteht, dass threadlokale Variablen zerstört werden, wenn der Thread abgeschlossen ist. Wenn der Thread wiederverwendet und einem neuen Aufruf asyncbereitgestellt wird, sind die alten Variablen weiterhin vorhanden. Es wird empfohlen, threadlokale Variablen nicht mit async.

Wenn die Richtlinie lautet launch::deferred, markiert die Funktion den zugeordneten asynchronen Zustand als Haltezeichen für eine verzögerte Funktion und gibt zurück. Der erste Aufruf einer nicht zeitgesteuerten Funktion, die darauf wartet, dass der entsprechende assoziierte asynchrone Zustand bereit ist, ruft effektiv die verzögerte Funktion auf, indem INVOKE(dfn, dargs..., Ty) ausgewertet wird.

In allen Fällen ist der zugeordnete asynchrone Zustand des future Objekts erst bereit, wenn die Auswertung INVOKE(dfn, dargs..., Ty) abgeschlossen ist, entweder durch Auslösen einer Ausnahme oder durch zurückgeben. Das Ergebnis des assoziierten asynchronen Zustands ist eine Ausnahm, sofern eine ausgelöst wurde, oder ein beliebiger Wert, der von der Auswertung zurückgegeben wird.

Hinweis

Für einen future– oder das letzte shared_future– das an eine Aufgabe angefügt ist, die mit einer Aufgabe gestartet wurde std::async, blockiert der Destruktor, wenn die Aufgabe nicht abgeschlossen wurde. Das heißt, er blockiert, wenn dieser Thread noch nicht aufgerufen .get() wurde oder .wait() und die Aufgabe noch ausgeführt wird. Wenn ein future-Element, das von std::async erhalten wurde, außerhalb des lokalen Bereich verschoben wird, muss beim Schreiben von anderem Code, bei dem es verwendet wird, beachtet werden, dass der Destruktor möglicherweise blockiert, damit der Freigabezustand in den Bereitschaftszustand wechseln kann.

Die Pseudofunktion INVOKE ist definiert in <functional>.

Microsoft-spezifisch

Wenn die übergebene Funktion asynchron ausgeführt wird, wird sie im Windows-Threadpool ausgeführt. siehe Threadpools. Die Anzahl der gleichzeitigen Threads ist auf den Threadpoolstandard (derzeit 500) beschränkt. Die Anzahl der Threads, die gleichzeitig auf Hardware ausgeführt werden, ist derzeit durch die Anzahl der logischen Prozessorgruppen des Prozesses begrenzt, sodass sie effektiv auf 64 beschränkt ist. siehe Prozessorgruppen.

future_category

Gibt einen Verweis auf das error_category-Objekt zurück, das Fehler bestimmt, die future-Objekten zugeordnet werden.

const error_category& future_category() noexcept;

make_error_code

Erstellt ein error_code-Objekt zusammen mit dem error_category-Objekt, mit dem zukünftige Fehler bestimmt werden.

inline error_code make_error_code(future_errc Errno) noexcept;

Parameter

Errno
Ein future_errc-Wert, mit dem die gemeldeten Fehler identifiziert werden.

Rückgabewert

error_code(static_cast<int>(Errno), future_category());

make_error_condition

Erstellt ein error_condition-Objekt zusammen mit dem error_category-Objekt, das future-Fehler bestimmt.

inline error_condition make_error_condition(future_errc Errno) noexcept;

Parameter

Errno
Ein future_errc-Wert, mit dem die gemeldeten Fehler identifiziert werden.

Rückgabewert

error_condition(static_cast<int>(Errno), future_category());

swap

Tauscht den zugeordneten asynchronen Zustand eines promise-Objekts mit dem des anderen aus.

template <class Ty>
void swap(promise<Ty>& Left, promise<Ty>& Right) noexcept;

template <class Ty, class... ArgTypes>
void swap(packaged_task<Ty(ArgTypes...)>& Left, packaged_task<Ty(ArgTypes...)>& Right) noexcept;

Parameter

Left
Das linke promise-Objekt.

Right
Das rechte promise-Objekt.

Weitere Informationen

<future>