<future> funktioner

Rubriken <future> innehåller följande funktioner:

async

Representerar en asynkron provider.

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

Parameterar

policy
Ett launch värde.

Anmärkningar

Definitioner av förkortningar:

Förkortning	Beskrivning
dfn	Resultatet av att anropa decay_copy(forward<Fn>(fn)).
dargs	Resultatet av anropen decay_copy(forward<ArgsTypes>(args...)).
Ty	Typen result_of<Fn(ArgTypes...)>::type.

Den första mallfunktionen returnerar async(launch::any, fn, args...).

Den andra funktionen returnerar ett future<Ty> objekt vars associerade asynkrona tillstånd innehåller ett resultat tillsammans med värdena dfn för och dargs och ett trådobjekt för att hantera en separat körningstråd.

Om inte decay<Fn>::type är en annan typ än start, deltar inte den andra funktionen i överbelastningsupplösning.

C++-standarden anger att om principen är launch::asyncfungerar funktionen som om den anropar det anropbara objektet i en ny tråd. Det innebär att även om det vanligtvis resulterar i att en ny tråd skapas, kan implementeringen använda andra mekanismer för att uppnå motsvarande beteende. Microsoft-implementeringen överensstämmer för närvarande dock inte strikt med det här beteendet. Den hämtar trådar från Windows ThreadPool, som kan ge en återvunnen tråd i stället för en ny. Det innebär att launch::async principen implementeras effektivt som launch::async|launch::deferred. En annan konsekvens av den ThreadPool-baserade implementeringen är att det inte finns någon garanti för att trådlokala variabler förstörs när tråden är klar. Om tråden återanvänds och tillhandahålls till ett nytt anrop till asyncfinns de gamla variablerna fortfarande. Vi rekommenderar att du undviker att använda trådlokala variabler med async.

Om policy är launch::deferredmarkerar funktionen dess associerade asynkrona tillstånd som att den har en uppskjuten funktion och returnerar. Det första anropet till en icke-tidsbegränsad funktion som väntar på att det associerade asynkrona tillståndet ska vara klart anropar den uppskjutna funktionen genom att INVOKE(dfn, dargs..., Ty)utvärdera .

I samtliga fall är det associerade asynkrona tillståndet för future objektet inte inställt på redo förrän utvärderingen av INVOKE(dfn, dargs..., Ty) slutförts, antingen genom att utlösa ett undantag eller genom att returnera normalt. Resultatet av det associerade asynkrona tillståndet är ett undantag om ett utlöses, eller om värdet som utvärderingen returnerar.

Anmärkning

För en future– eller den sista shared_future– som är kopplad till en aktivitet som startats med std::async, blockeras destructor om aktiviteten inte har slutförts, det vill säga blockeras om den här tråden inte anropades .get() eller .wait() om aktiviteten fortfarande körs. Om en future hämtad från std::async flyttas utanför det lokala omfånget måste annan kod som använder den vara medveten om att dess destructor kan blockera för att det delade tillståndet ska bli klart.

Pseudofunktionen INVOKE definieras i <functional>.

Microsoft-specifika

När den skickade funktionen körs asynkront körs den på Windows-trådpoolen. Mer information finns i Trådpooler. Antalet samtidiga trådar är begränsat till standardvärdet för trådpoolen, vilket är 500 trådar.

Före Windows 11 och Windows Server 2022 begränsades programmen som standard till en enda processorgrupp med högst 64 logiska processorer. Detta begränsade antalet trådar som körs samtidigt till 64. Mer information finns i processorgrupper.

Från och med Windows 11 och Windows Server 2022 har processer och deras trådar processortillhörighet som som standard sträcker sig över alla processorer i systemet och över flera grupper på datorer med mer än 64 processorer. Gränsen för antalet samtidiga trådar är nu det totala antalet logiska processorer i systemet.

future_category

Returnerar en referens till objektet error_category som karakteriserar fel som är associerade med future objekt.

const error_category& future_category() noexcept;

make_error_code

Skapar en error_code tillsammans med det error_category objekt som karakteriserar framtida fel.

inline error_code make_error_code(future_errc Errno) noexcept;

Parameterar

Errno
Ett future_errc värde som identifierar det rapporterade felet.

Returvärde

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

make_error_condition

Skapar ett error_condition tillsammans med det error_category objekt som kännetecknar future fel.

inline error_condition make_error_condition(future_errc Errno) noexcept;

Parameterar

Errno
Ett future_errc värde som identifierar det rapporterade felet.

Returvärde

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

swap

Utbyter det associerade asynkrona tillståndet för ett promise objekt med det andra objektets.

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;

Parameterar

Left
Det vänstra promise objektet.

Right
Det högra promise objektet.

Se även

<future>