<future> függvények

A <future> fejléc a következő függvényeket biztosítja:

async

Aszinkron szolgáltatót jelöl.

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

Paraméterek

policy
Egy launch érték.

Megjegyzések

Rövidítések definíciói:

Rövidítés	Leírás
dfn	A hívás decay_copy(forward<Fn>(fn))eredménye.
dargs	A hívások decay_copy(forward<ArgsTypes>(args...))eredményei.
Ty	A típus result_of<Fn(ArgTypes...)>::type.

Az első sablonfüggvény ad async(launch::any, fn, args...)vissza.

A második függvény egy future<Ty> olyan objektumot ad vissza, amelynek a társított aszinkron állapota egy eredményt tartalmaz az értékekkel dfndargs és egy szálobjektummal együtt egy külön végrehajtási szál kezeléséhez.

A második függvény nem vesz részt a túlterhelés feloldásában, kivéve, ha decay<Fn>::type az indítástól eltérő típusról van szó.

A C++ szabvány azt állítja, hogy ha a szabályzat az launch::async, a függvény úgy viselkedik, mintha egy új szálban hívja meg a hívható objektumot. Ez azt jelenti, hogy bár ez általában egy új szál létrehozását eredményezi, a megvalósítás más mechanizmusokat is használhat az egyenértékű viselkedés eléréséhez. A Microsoft implementációja azonban jelenleg nem felel meg szigorúan ennek a viselkedésnek. A Windows ThreadPoolból szerzi be a szálakat, amelyek újrahasznosított szálat biztosíthatnak, nem pedig újat. Ez azt jelenti, hogy a launch::async szabályzat gyakorlatilag a következőképpen van implementálva launch::async|launch::deferred: . A ThreadPool-alapú implementáció egy másik következménye, hogy nincs garancia arra, hogy a szál helyi változói megsemmisülnek a szál befejezésekor. Ha a szál újrahasznosított, és egy új híváshoz asyncvan adva, a régi változók továbbra is léteznek. Javasoljuk, hogy kerülje a szál-helyi változók használatát a következővel async: .

Ha policy igen launch::deferred, a függvény a társított aszinkron állapotot halasztott függvényként jelöli meg, és visszaadja. Minden olyan nem időzített függvény első hívása, amely arra vár, hogy a társított aszinkron állapot készen álljon, meghívja a késleltetett függvényt a kiértékeléssel INVOKE(dfn, dargs..., Ty).

Az objektum társított aszinkron állapota future minden esetben nem áll készen a befejezések kiértékeléséig INVOKE(dfn, dargs..., Ty) , akár kivétel kivetésével, akár normál visszatéréssel. A társított aszinkron állapot eredménye kivétel, ha egy ki lett dobva, vagy a kiértékelés eredménye.

Megjegyzés:

Ha a futuredestruktor egy megkezdett shared_futuretevékenységhez van csatolva – vagy az utolsó std::async–, akkor a destruktor blokkolja, ha a tevékenység még nem fejeződött be, vagyis letiltja, ha ez a szál még nem hívott, .get() vagy .wait() a tevékenység még fut. Ha a future kapott adatok std::async a helyi hatókörön kívülre kerülnek, az azt használó más kódnak tisztában kell lennie azzal, hogy a destruktor blokkolhatja a megosztott állapot készenlétét.

A pszeudofüggvény INVOKE a következőben van definiálva <functional>: .

Microsoft-specifikus

Az átadott függvény aszinkron végrehajtásakor a Windows-szálkészleten hajtja végre. További információ: Szálkészletek. Az egyidejű szálak száma az alapértelmezett szálkészletre korlátozódik, ami 500 szál.

A Windows 11 és a Windows Server 2022 előtt az alkalmazások alapértelmezés szerint egyetlen processzorcsoportra korlátozódtak, amely legfeljebb 64 logikai processzorral rendelkezik. Ez az egyidejűleg végrehajtó szálak számát 64-re korlátozta. További információ: Processzorcsoportok.

A Windows 11-től és a Windows Server 2022-től kezdve a folyamatok és szálaik processzor-affinitásokkal rendelkeznek, amelyek alapértelmezés szerint a rendszer összes processzorára és több csoportra kiterjednek a 64-nél több processzorral rendelkező gépeken. Az egyidejű szálak számának korlátja most a rendszerben lévő logikai processzorok teljes száma.

future_category

Az objektumhoz error_category társított future hibákat jellemző objektumra mutató hivatkozást ad vissza.

const error_category& future_category() noexcept;

make_error_code

Létrehoz egy error_code a jövőbeli hibákat jellemző error_category objektummal együtt.

inline error_code make_error_code(future_errc Errno) noexcept;

Paraméterek

Errno
A future_errc jelentett hibát azonosító érték.

Visszaadott érték

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

make_error_condition

error_condition A hibákat jellemző error_category objektummal future együtt hoz létre.

inline error_condition make_error_condition(future_errc Errno) noexcept;

Paraméterek

Errno
A future_errc jelentett hibát azonosító érték.

Visszaadott érték

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

swap

Az egyik objektum promise cseréli le egy másik objektum állapotával.

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;

Paraméterek

Left
A bal oldali promise objektum.

Right
A megfelelő promise objektum.

Lásd még

<future>