<future> -Funktionen

  • Artikel

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 sich die Funktion, wenn die Richtlinie lautet launch::async, so verhält, als ob das aufrufbare Objekt in einem neuen Thread aufgerufen wird. Dies bedeutet, dass die Implementierung in der Regel zu einem neuen Thread führt, andere Mechanismen verwenden kann, um ein entsprechendes Verhalten zu erzielen. Die Microsoft-Implementierung entspricht derzeit jedoch nicht genau diesem Verhalten. Er ruft seine Threads aus dem Windows ThreadPool ab, die einen wiederverwendeten Thread anstelle eines neuen Threads bereitstellen können. Dies bedeutet, dass die launch::async Richtlinie effektiv implementiert wird.launch::async|launch::deferred 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, die Verwendung von threadlokalen Variablen 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.

Siehe auch

<future>