Funkce oboru názvů pro souběžnost

V oboru názvů jsou k dispozici následující funkce:

Alloc

Přidělí blok paměti o zadané velikosti z mezipaměťového dílčího alokátoru Concurrency Runtime.

void* __cdecl Alloc(size_t _NumBytes);

Parametry

_NumBytes
Počet bajtů paměti, které se mají přidělit.

Návratová hodnota

Ukazatel na nově přidělenou paměť.

Poznámky

Další informace o tom, které scénáře ve vaší aplikaci mohou těžit z použití suballokátoru pro ukládání do mezipaměti, naleznete v části Task Scheduler.

asend

Asynchronní odesílací operace, která naplánuje úlohu předání dat do cílového bloku.

template <class T>
bool asend(
    _Inout_ ITarget<T>* _Trg,
    const T& _Data);

template <class T>
bool asend(
    ITarget<T>& _Trg,
    const T& _Data);

Parametry

T
Typ dat, která se mají odeslat.

_Trg
Ukazatel nebo odkaz na cíl, na který se data odesílají.

_Data
Odkaz na data, která se mají odeslat.

Návratová hodnota

pokud byla zpráva přijata před vrácenou metodou, jinak.

Poznámky

Další informace naleznete v tématu Funkce předávání zpráv.

zrušit_aktuální_úlohu

Zruší aktuálně spuštěnou úlohu. Tuto funkci lze volat z těla úkolu, aby se přerušila spuštění úkolu a způsobila, že přejde do stavu.

Volání této funkce není podporovaným scénářem, pokud nejste uvnitř těla komponenty . Výsledkem bude nedefinované chování, jako je chybové ukončení nebo nereagování ve vaší aplikaci.

inline __declspec(noreturn) void __cdecl cancel_current_task();

odznačit

Vymaže souběžnou frontu a zničí všechny aktuálně zařazené prvky. Tato metoda není bezpečná pro souběžnost.

template<typename T, class _Ax>
void concurrent_queue<T, _Ax>::clear();

Parametry

_Ax

create_async

Vytvoří prostředí Windows Runtime asynchronní konstruktor založený na uživateli zadaném objektu lambda nebo funkce. Návratový typ je jedním z těchto: , , nebo na základě podpisu lamdy předané metodě.

template<typename _Function>
__declspec(noinline) auto create_async(const _Function& _Func)
    -> decltype(ref new details::_AsyncTaskGeneratorThunk<_Function>(_Func));

Parametry

_Funkce
Typ:

_Func
Lambda nebo objekt funkce, ze kterého chcete vytvořit asynchronní konstrukci prostředí Windows Runtime.

Návratová hodnota

Asynchronní konstruktor reprezentovaný IAsyncAction^, IAsyncActionWithProgress TProgress^, IAsyncOperationTResult^ nebo IAsyncOperationWithProgressTResult, TProgress^. Vrácené rozhraní závisí na signatuře lambda předané do funkce.

Poznámky

Návratový typ lambda určuje, zda je konstrukce akcí nebo operací.

Lambda, které vracejí void, způsobují vytváření akcí. Lambda, které vrací výsledek typu , způsobují vytvoření operací TResult.

Lambda může také vrátit , které zapouzdřuje asynchronní práci uvnitř sebe nebo je součástí řetězce úkolů představujících asynchronní práci. V tomto případě je lambda spuštěna přímo, protože úlohy se spouští asynchronně, a návratový typ lambda je rozbalen, aby vytvořil asynchronní konstrukci vrácenou . To znamená, že lambda, která vrací úkol, způsobí vytvoření akcí, a lambda, která vrátí úkol, způsobí vytvoření operací TResult.

Lambda může mít buď nula, jeden nebo dva argumenty. Platné argumenty jsou a v tom pořadí, pokud se použijí oba. Lambda bez argumentů způsobí vytvoření asynchronní konstrukce bez schopnosti poskytování hlášení o průběhu. Lambda, která přebírá progress_reporterTProgress, způsobí, že vrátí asynchronní konstrukci, která hlásí průběh typu TProgress pokaždé, když je metoda objektu progress_reporter volána. Lambda, která přebírá token pro zrušení, může tento token použít ke kontrole zrušení, nebo ho předat úkolům, které vytvoří, takže zrušení asynchronní konstrukce způsobí zrušení těchto úkolů.

Pokud tělo lambda nebo objekt funkce vrátí výsledek (a ne úkolTResult), lambda se spustí asynchronně v rámci procesu MTA v kontextu úlohy, pro který modul runtime implicitně vytvoří. Metoda způsobí zrušení implicitní úlohy.

Pokud tělo lambdy vrátí úlohu, lambda se vykoná inline, a zadáním argumentu typu pro lambdu můžete zrušit libovolné úlohy, které v lambdě vytvoříte, předáním tohoto tokenu při jejich vytváření. Můžete také použít metodu tokenu, která způsobí, že modul runtime vyvolá zpětné volání při volání na asynchronní operaci nebo akci vytvořenou.

Tato funkce je dostupná jenom pro prostředí Windows Runtime aplikace.

CreateResourceManager

Vrátí rozhraní, které představuje unikátní instanci správce zdrojů systému Concurrency Runtime. Resource Manager zodpovídá za přiřazování prostředků plánovačům, kteří spolu chtějí spolupracovat.

IResourceManager* __cdecl CreateResourceManager();

Návratová hodnota

Rozhraní .

Poznámky

Více následných volání této metody vrátí stejnou instanci Resource Manager. Každé volání metody zvýší počet odkazů na Resource Manager a musí se shodovat s voláním metody IResourceManager::Release, když plánovač dokončí komunikaci s Resource Manager.

unsupported_os je vyvolán, pokud není operační systém podporován modulem Concurrency Runtime.

vytvořit_úkol

Vytvoří objekt úkolu PPL. lze použít kdekoli, kde byste použili konstruktor úloh. Poskytuje se hlavně pro usnadnění práce, protože umožňuje použití klíčového slova při vytváření úloh.

template<typename T>
__declspec(noinline) auto create_task(T _Param, const task_options& _TaskOptions = task_options())
    -> task<typename details::_TaskTypeFromParam<T>::T>;

template<typename _ReturnType>
__declspec( noinline) task<_ReturnType> create_task(const task<_ReturnType>& _Task);

Parametry

T
Typ parametru, ze kterého má být úkol vytvořen.

_ReturnType
Typ:

_Param
Parametr, ze kterého má být úkol vytvořen. Může to být objekt lambda nebo funkce, objekt task_completion_event, jiný objekt task nebo Windows::Foundation::IAsyncInfo rozhraní, pokud používáte úlohy v aplikaci UPW.

_TaskOptions
Možnosti úkolu.

_Úkol
Úkol k vytvoření.

Návratová hodnota

Nový úkol typu , který je odvozen z .

Poznámky

První přetížení se chová jako konstruktor úkolu, který přebírá jeden parametr.

Druhé přetížení přidružuje poskytnutý token zrušení k nově vytvořené úloze. Pokud použijete toto přetížení, nesmíte předat jiný objekt jako první parametr.

Typ vrácené úlohy je odvozen z prvního parametru do funkce. Pokud je , nebo functor, který vrací buď typ nebo , typ vytvořeného úkolu je .

Pokud je v aplikaci pro UPW _Param typu Windows::Foundation::IAsyncOperation<T>^ nebo Windows::Foundation::IAsyncOperationWithProgress<T,P>^, nebo functor, který vrátí některý z těchto typů, vytvořený úkol bude typu task<T>. Pokud je _Param typu Windows::Foundation::IAsyncAction^ nebo Windows::Foundation::IAsyncActionWithProgress<P>^, nebo functor, který vrátí některý z těchto typů, bude mít vytvořený úkol typ task<void>.

ZakázatSledování

Zakáže trasování v Concurrency Runtime. Tato funkce je zastaralá, protože ETW trasování není ve výchozím nastavení registrováno.

__declspec(deprecated("Concurrency::DisableTracing is a deprecated function.")) _CRTIMP HRESULT __cdecl DisableTracing();

Návratová hodnota

Pokud bylo trasování správně zakázané, vrátí se . Pokud trasování nebylo zahájeno dříve, je vráceno.

Povolit trasování

Povolí trasování v Concurrency Runtime. Tato funkce je zastaralá, protože sledování událostí pro Windows (ETW) je teď ve výchozím nastavení zapnuté.

__declspec(deprecated("Concurrency::EnableTracing is a deprecated function.")) _CRTIMP HRESULT __cdecl EnableTracing();

Návratová hodnota

Pokud bylo trasování správně zahájeno, vrátí se. V opačném případě se vrátí.

Free

Uvolní blok paměti, který byl dříve přidělen metodou ke suballocátoru mezipaměti Concurrency Runtime.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

Parametry

_PAllocation
Ukazatel na paměť, která byla dříve přidělena metodou , a má být uvolněna. Pokud je parametr nastaven na hodnotu , tato metoda ji ignoruje a vrátí okamžitě.

Poznámky

Další informace o tom, které scénáře ve vaší aplikaci mohou těžit z použití suballokátoru pro ukládání do mezipaměti, naleznete v části Task Scheduler.

get_ambient_scheduler

inline std::shared_ptr<::Concurrency::scheduler_interface> get_ambient_scheduler();

Návratová hodnota

GetExecutionContextId

Vrátí jedinečný identifikátor, který lze přiřadit kontextu spuštění, který implementuje rozhraní.

unsigned int __cdecl GetExecutionContextId();

Návratová hodnota

Jedinečný identifikátor kontextu spuštění.

Poznámky

Tuto metodu použijte k získání identifikátoru kontextu spuštění před předáním rozhraní IExecutionContext jako parametru pro kteroukoli z metod nabízených Resource Manager.

GetOSVersion

Vrátí verzi operačního systému.

IResourceManager::OSVersion __cdecl GetOSVersion();

Návratová hodnota

Výčtová hodnota představující operační systém.

Poznámky

unsupported_os je vyvolán, pokud není operační systém podporován modulem Concurrency Runtime.

GetProcessorCount

Vrátí počet hardwarových vláken v podkladovém systému.

unsigned int __cdecl GetProcessorCount();

Návratová hodnota

Počet hardwarových vláken.

Poznámky

unsupported_os je vyvolán, pokud není operační systém podporován modulem Concurrency Runtime.

GetProcessorNodeCount

Vrátí počet uzlů NUMA nebo balíčků procesoru v podkladovém systému.

unsigned int __cdecl GetProcessorNodeCount();

Návratová hodnota

Počet uzlů NUMA nebo balíčků procesoru

Poznámky

Pokud systém obsahuje více uzlů NUMA než balíčky procesoru, vrátí se počet uzlů NUMA, jinak se vrátí počet balíčků procesoru.

unsupported_os je vyvolán, pokud není operační systém podporován modulem Concurrency Runtime.

GetSchedulerId

Vrátí jedinečný identifikátor, který lze přiřadit plánovači, který implementuje rozhraní.

unsigned int __cdecl GetSchedulerId();

Návratová hodnota

Jedinečný identifikátor plánovače.

Poznámky

Tuto metodu použijte k získání identifikátoru plánovače před předáním rozhraní IScheduler jako parametru pro některou z metod nabízených Resource Manager.

internal_assign_iterators

template<typename T, class _Ax>
template<class _I>
void concurrent_vector<T, _Ax>::internal_assign_iterators(
   _I first,
   _I last);

Parametry

_Ax

_Já

první

poslední

bod přerušení

Vytvoří bod přerušení pro zrušení. Pokud probíhá zrušení v kontextu, kde je tato funkce volána, vyvolá se vnitřní výjimka, která přeruší provádění aktuálně spuštěné paralelní práce. Pokud zrušení neprobíhá, funkce nic nedělá.

inline void interruption_point();

Poznámky

Neměli byste zachytávat interní výjimku zrušení vyvolanou funkcí . Výjimka bude zachycena a zpracována modulem runtime a zachycení může způsobit, že se váš program bude chovat neobvykle.

je_skupina_aktuálních_úkolů_rušena

Vrátí informaci o tom, jestli je skupina úloh, která se právě spouští v aktuálním kontextu, uprostřed aktivního zrušení (nebo brzy). Všimněte si, že pokud v aktuálním kontextu aktuálně nespouští žádná skupina úloh inline, bude vrácena.

bool __cdecl is_current_task_group_canceling();

Návratová hodnota

pokud se skupina úloh, která se právě spouští, ruší, jinak.

Poznámky

Další informace najdete v tématu Zrušení.

make_choice

Vytvoří blok zasílání zpráv z volitelných nebo dvou nebo více vstupních zdrojů.

template<typename T1, typename T2, typename... Ts>
choice<std::tuple<T1, T2, Ts...>> make_choice(
    Scheduler& _PScheduler,
    T1  _Item1,
    T2  _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
choice<std::tuple<T1, T2, Ts...>> make_choice(
    ScheduleGroup& _PScheduleGroup,
    T1  _Item1,
    T2  _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
choice<std::tuple<T1, T2, Ts...>> make_choice(
    T1  _Item1,
    T2  _Item2,
    Ts... _Items);

Parametry

T1
Typ bloku zprávy prvního zdroje

T2
Typ bloku zprávy druhého zdroje

_PScheduler
Objekt , ve kterém je naplánována úloha šíření bloku zasílání zpráv.

_Item1
První zdroj.

_Item2
Druhý zdroj.

_Položky
Další zdroje.

_PScheduleGroup
Objekt , ve kterém je naplánována úloha šíření bloku zasílání zpráv. Použití objektu je dané skupinou plánů.

Návratová hodnota

Blok zprávy se dvěma nebo více vstupními zdroji

make_greedy_join

Vytvoří blok zasílání zpráv z volitelných nebo dvou nebo více vstupních zdrojů.

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>,greedy> make_greedy_join(
    Scheduler& _PScheduler,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>, greedy> make_greedy_join(
    ScheduleGroup& _PScheduleGroup,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>, greedy> make_greedy_join(
    T1 _Item1,
    T2 _Items,
    Ts... _Items);

Parametry

T1
Typ bloku zprávy prvního zdroje

T2
Typ bloku zprávy druhého zdroje

_PScheduler
Objekt , ve kterém je naplánována úloha šíření bloku zasílání zpráv.

_Item1
První zdroj.

_Item2
Druhý zdroj.

_Položky
Další zdroje.

_PScheduleGroup
Objekt , ve kterém je naplánována úloha šíření bloku zasílání zpráv. Použití objektu je dané skupinou plánů.

Návratová hodnota

Blok zprávy se dvěma nebo více vstupními zdroji

vytvořit_spojení

Vytvoří blok zasílání zpráv z volitelných nebo dvou nebo více vstupních zdrojů.

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>>
    make_join(
Scheduler& _PScheduler,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>> make_join(
ScheduleGroup& _PScheduleGroup,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>> make_join(
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

Parametry

T1
Typ bloku zprávy prvního zdroje

T2
Typ bloku zprávy druhého zdroje

_PScheduler
Objekt , ve kterém je naplánována úloha šíření bloku zasílání zpráv.

_Item1
První zdroj.

_Item2
Druhý zdroj.

_Položky
Další zdroje.

_PScheduleGroup
Objekt , ve kterém je naplánována úloha šíření bloku zasílání zpráv. Použití objektu je dané skupinou plánů.

Návratová hodnota

Blok zprávy se dvěma nebo více vstupními zdroji

make_task

Tovární metoda pro vytvoření objektu .

template <class _Function>
task_handle<_Function> make_task(const _Function& _Func);

Parametry

_Funkce
Typ objektu funkce, který bude vyvolán ke spuštění práce reprezentované objektem .

_Func
Funkce, která bude vyvolána ke spuštění práce reprezentované objektem . Může to být lambda functor, ukazatel na funkci nebo jakýkoli objekt, který podporuje verzi operátoru volání funkce s podpisem .

Návratová hodnota

Objekt .

Poznámky

Tato funkce je užitečná, když potřebujete vytvořit objekt s výrazem lambda, protože umožňuje vytvořit objekt bez znalosti skutečného typu lambda functor.

paralelní třídění s vyrovnávací pamětí

Uspořádá prvky v zadaném rozsahu do nesestupné pořadí nebo podle kritéria řazení určeného binárním predikátem paralelně. Tato funkce je sémanticky podobná tomu, že se jedná o porovnávané, nestabilní, místní řazení s tím rozdílem, že potřebuje další prostor a vyžaduje výchozí inicializaci pro seřazené prvky.

template<typename _Random_iterator>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator,
    typename _Random_iterator>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator,
    typename _Random_iterator>
inline void parallel_buffered_sort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Random_iterator,
    typename _Function>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

template<typename _Allocator,
    typename _Random_iterator,
    typename _Function>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

template<typename _Allocator,
    typename _Random_iterator,
    typename _Function>
inline void parallel_buffered_sort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

Parametry

_Random_iterator
Typ iterátoru vstupního rozsahu.

_Alokátor
Typ alokátoru paměti kompatibilní se standardní knihovnou jazyka C++.

_Funkce
Typ binárního komparátoru.

_Začít
Iterátor náhodného přístupu adresuje pozici prvního prvku v oblasti, která se má seřadit.

_Konec
Iterátor náhodného přístupu, který adresuje pozici těsně za posledním prvkem v oblasti, která se má seřadit.

_Alloc
Instance alokátoru paměti kompatibilní se standardní knihovnou jazyka C++.

_Func
Uživatelem definovaný predikát objekt funkce, který definuje kritérium porovnání, které má být splněno po sobě jdoucími prvky v pořadí. Binární predikát přebírá dva argumenty a vrací při jejich splnění a při jejich nesplnění. Tato porovnávací funkce musí u párů prvků ze sekvence uložit striktní slabé pořadí.

_Chunk_size
Minimální velikost bloku dat, který bude rozdělen na dva pro paralelní provádění.

Poznámky

Všechna přetížení vyžadují další prostor, kde je počet prvků, které mají být seřazeny, a je typ prvku. Ve většině případů parallel_buffered_sort zobrazí zlepšení výkonu oproti parallel_sort a pokud máte k dispozici paměť, měli byste ho použít přes parallel_sort.

Pokud nezadáte binární komparátor , použije se jako výchozí, který vyžaduje typ prvku k poskytnutí operátoru .

Pokud nezadáte typ nebo instanci alokátoru, k přidělení vyrovnávací paměti se použije alokátor standardní knihovny jazyka C++.

Algoritmus rozdělí vstupní rozsah na dva bloky dat a postupně rozdělí každý blok dat do dvou dílčích bloků dat pro paralelní spuštění. Volitelný argument lze použít k označení algoritmu, že by měl zpracovávat bloky velikosti serialně.

parallel_for

iteruje v rozsahu indexů a provádí uživatelsky zadanou funkci paralelně při každé iteraci.

template <typename _Index_type, typename _Function, typename _Partitioner>
void parallel_for(
    _Index_type first,
    _Index_type last,
    _Index_type _Step,
    const _Function& _Func,
    _Partitioner&& _Part);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    _Index_type _Step,
    const _Function& _Func);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    const auto_partitioner& _Part = auto_partitioner());

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    const static_partitioner& _Part);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    const simple_partitioner& _Part);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    affinity_partitioner& _Part);

Parametry

_Index_type
Typ indexu, který se používá pro iteraci.

_Funkce
Typ funkce, která se spustí při každé iteraci.

_Partitioner
Typ rozdělovače, který se používá k rozdělení zadaného rozsahu.

první
První index, který se má zahrnout do iterace.

poslední
Index je za posledním indexem, který se má zahrnout do iterace.

_Krok
Hodnota, o kterou se má krokovat při iteraci z do . Tento krok musí být pozitivní. invalid_argument je vyvolán, pokud je krok menší než 1.

_Func
Funkce, která se má spustit při každé iteraci. Může se jednat o výraz lambda, ukazatel funkce nebo jakýkoli objekt, který podporuje verzi operátoru volání funkce s podpisem .

_Část
Odkaz na objekt partitioneru. Argumentem může být jeden z auto_partitioner, static_partitioner, simple_partitioner nebo affinity_partitioner. Pokud je použit objekt affinity_partitioner, odkaz musí být nekonstantní l-hodnota, aby algoritmus mohl uložit stav a znovu jej použít v budoucích smyčkách.

Poznámky

Další informace naleznete v tématu Paralelní algoritmy.

parallel_for_each

použije zadanou funkci na každý prvek v rozsahu paralelně. Je sémanticky ekvivalentní funkci v oboru názvů s tím rozdílem, že iterace nad prvky se provádí paralelně a pořadí iterace není zadáno. Argument musí podporovat operátor volání funkce ve formě , kde parametr je typ položky kontejneru používaného pro iteraci.

template <typename _Iterator, typename _Function>
void parallel_for_each(
    _Iterator first,
    _Iterator last,
    const _Function& _Func);

template <typename _Iterator, typename _Function, typename _Partitioner>
void parallel_for_each(
    _Iterator first,
    _Iterator last,
    const _Function& _Func,
    _Partitioner&& _Part);

Parametry

_Iterátor
Typ iterátoru, který se používá k iteraci přes kontejner.

_Funkce
Typ funkce, která bude použita pro každý prvek v rozsahu.

_Partitioner
první
Iterátor adresuje pozici prvního prvku, který se má zahrnout do paralelní iterace.

poslední
Iterátor adresuje pozici po posledním prvku, který se má zahrnout do paralelní iterace.

_Func
Uživatelem definovaný objekt funkce, který je použit pro každý prvek v rozsahu.

Poznámky

auto_partitioner bude použita pro přetížení bez explicitního dělitele.

Pro iterátory, které nepodporují náhodný přístup, se podporuje pouze auto_partitioner .

Další informace naleznete v tématu Paralelní algoritmy.

parallel_invoke

Spustí objekty funkcí zadané jako parametry paralelně a čeká, dokud není jejich provádění dokončeno. Každý objekt funkce může být výraz lambda, ukazatel na funkci nebo jakýkoli objekt, který podporuje operátor volání funkce s podpisem .

template <typename _Function1, typename _Function2>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2);

template <typename _Function1, typename _Function2, typename _Function3>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7,
    typename _Function8>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7,
    const _Function8& _Func8);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7,
    typename _Function8,
    typename _Function9>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7,
    const _Function8& _Func8,
    const _Function9& _Func9);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7,
    typename _Function8,
    typename _Function9,
    typename _Function10>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7,
    const _Function8& _Func8,
    const _Function9& _Func9,
    const _Function10& _Func10);

Parametry

_Function1
Typ prvního objektu funkce, který se má spustit paralelně.

_Function2
Typ druhého objektu funkce, který se má spustit paralelně.

_Function3
Typ třetího objektu funkce, který se má spustit paralelně.

_Function4
Typ čtvrtého objektu funkce, který se má spustit paralelně.

_Function5
Typ pátého objektu funkce, který se má spustit paralelně.

_Function6
Typ šestého objektu funkce, který se má spustit paralelně.

_Function7
Typ sedmého objektu funkce, který se má spustit paralelně.

_Function8
Typ osmého objektu funkce, který se má spustit paralelně.

_Function9
Typ devátého objektu funkce, který se má spustit paralelně.

_Function10
Typ desátého objektu funkce, který se má spustit paralelně.

_Func1
První objekt funkce, který se má spustit paralelně.

_Func2
Druhý objekt funkce, který se má spustit paralelně.

_Func3
Třetí objekt funkce, který se má spustit paralelně.

_Func4
Čtvrtý objekt funkce, který se má spustit paralelně.

_Func5
Pátý objekt funkce, který se má spustit paralelně.

_Func6
Šestý objekt funkce, který se má spustit paralelně.

_Func7
Sedmý objekt funkce, který se má spustit paralelně.

_Func8
Osmý objekt funkce, který se má spustit paralelně.

_Func9
Devátý objekt funkce, který se má spustit paralelně.

_Func10
Desátý objekt funkce, který se má spustit paralelně.

Poznámky

Všimněte si, že jeden nebo více objektů funkcí zadaných jako parametry se může spustit v kontextu volání.

Pokud jeden nebo více funkčních objektů předaných jako parametry této funkce vyvolá výjimku, běhové prostředí vybere jednu takovou výjimku podle vlastního výběru a rozšíří ji mimo volání .

Další informace naleznete v tématu Paralelní algoritmy.

paralelní_radixsort

Uspořádá prvky v zadaném rozsahu do nesestupného pořadí pomocí algoritmu číselného řazení. Jedná se o stabilní funkci řazení, která vyžaduje projekční funkci sloužící k projekci prvků do klíče ve formě nepodepsaného celého čísla. Pro seřazené prvky se vyžaduje výchozí inicializace.

template<typename _Random_iterator>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator, typename _Random_iterator>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator, typename _Random_iterator>
inline void parallel_radixsort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Random_iterator, typename _Function>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Proj_func,
    const size_t _Chunk_size = 256* 256);

template<typename _Allocator, typename _Random_iterator,
    typename _Function>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Proj_func,
    const size_t _Chunk_size = 256* 256);

template<typename _Allocator,
    typename _Random_iterator,
    typename _Function>
inline void parallel_radixsort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Proj_func,
    const size_t _Chunk_size = 256* 256);

Parametry

_Random_iterator
Typ iterátoru vstupního rozsahu.

_Alokátor
Typ alokátoru paměti kompatibilní se standardní knihovnou jazyka C++.

_Funkce
Typ projekční funkce.

_Začít
Iterátor náhodného přístupu adresuje pozici prvního prvku v oblasti, která se má seřadit.

_Konec
Iterátor náhodného přístupu, který adresuje pozici těsně za posledním prvkem v oblasti, která se má seřadit.

_Alloc
Instance alokátoru paměti kompatibilní se standardní knihovnou jazyka C++.

_Proj_func
Objekt funkce projekce definovaný uživatelem, který převede prvek na celočíselnou hodnotu.

_Chunk_size
Minimální velikost bloku dat, který bude rozdělen na dva pro paralelní provádění.

Poznámky

Všechna přetížení vyžadují další prostor, kde je počet prvků, které mají být seřazeny, a je typ prvku. Unární projekční funkce s podpisem je vyžadována k vrácení klíče při zadání prvku, kde je typ prvku a je nepodepsaný celočíselný typ.

Pokud nezadáte projekční funkci, použije se výchozí projekční funkce, která jednoduše vrátí prvek pro celočíselné typy. Funkce se nepovede zkompilovat, pokud v nepřítomnosti projekční funkce prvek není celočíselným typem.

Pokud nezadáte typ nebo instanci alokátoru, k přidělení vyrovnávací paměti se použije alokátor standardní knihovny jazyka C++.

parallel_reduce

Vypočítá součet všech prvků v zadaném rozsahu výpočtem po sobě jdoucích částečných součtů nebo vypočítá výsledek po sobě jdoucích částečných výsledků podobně získaných pomocí zadané binární operace jiné než součet paralelně. je sémanticky podobný , s výjimkou toho, že vyžaduje, aby binární operace byla asociativní, a vyžaduje hodnotu identity místo počáteční hodnoty.

template<typename _Forward_iterator>
inline typename std::iterator_traits<_Forward_iterator>::value_type parallel_reduce(
    _Forward_iterator _Begin,
    _Forward_iterator _End,
    const typename std::iterator_traits<_Forward_iterator>::value_type& _Identity);

template<typename _Forward_iterator, typename _Sym_reduce_fun>
inline typename std::iterator_traits<_Forward_iterator>::value_type parallel_reduce(
    _Forward_iterator _Begin,
    _Forward_iterator _End,
    const typename std::iterator_traits<_Forward_iterator>::value_type& _Identity,
    _Sym_reduce_fun _Sym_fun);

template<typename _Reduce_type,
    typename _Forward_iterator,
    typename _Range_reduce_fun,
    typename _Sym_reduce_fun>
inline _Reduce_type parallel_reduce(
    _Forward_iterator _Begin,
    _Forward_iterator _End,
    const _Reduce_type& _Identity,
    const _Range_reduce_fun& _Range_fun,
    const _Sym_reduce_fun& _Sym_fun);

Parametry

_Forward_iterator
Typ iterátoru vstupního rozsahu.

_Sym_reduce_fun
Typ symetrické redukční funkce. Musí to být typ funkce s podpisem , kde _Reduce_type je stejný jako typ identity a typ výsledku redukce. Pro třetí přetížení by to mělo být konzistentní s typem výstupu .

_Reduce_type
Typ, na který se vstup sníží, což se může lišit od typu vstupního prvku. Vrácená hodnota a hodnota identity budou mít tento typ.

_Range_reduce_fun
Typ funkce redukce rozsahu. Musí to být typ funkce s podpisem , _Reduce_type je stejný jako typ identity a typ výsledku redukce.

_Začít
Vstupní iterátor adresující první prvek v rozsahu, který má být snížen.

_Konec
Vstupní iterátor adresovaný prvku, který je o jednu pozici nad posledním prvkem v rozsahu, který se má snížit.

_Identita
Hodnota identity je stejného typu jako typ výsledku redukce a také iterátoru pro první a druhé přetížení. U třetího přetížení musí mít hodnota identity stejný typ jako typ výsledku redukce, ale může se lišit od iterátoru. Musí mít vhodnou hodnotu, aby operátor redukce rozsahu, při použití na rozsah jednoho prvku typu a na identitní hodnotu, se choval jako přetypování hodnoty z typu na identitní typ.

_Sym_fun
Symetrická funkce, která se použije v sekundě redukce. Další informace najdete v poznámkách.

_Range_fun
Funkce, která se použije v první fázi redukce. Další informace najdete v poznámkách.

Návratová hodnota

Výsledek redukce.

Poznámky

K provedení paralelní redukce funkce rozdělí rozsah na úseky na základě počtu pracovníků dostupných pro podkladový plánovač. Redukce probíhá ve dvou fázích, první fáze provádí redukci v rámci každého bloku a druhá fáze provádí redukci mezi částečnými výsledky z každého bloku.

První přetížení vyžaduje, aby iterátor , byl stejný jako typ hodnoty identity a typ výsledku redukce. Typ elementu T musí poskytnout operátor pro redukci prvků v jednotlivých blocích. Stejný operátor se používá i ve druhé fázi.

Druhé přetížení také vyžaduje, aby iterátor byl stejný jako typ hodnoty identity i typ výsledku redukce. Zadaný binární operátor se používá v obou fázích redukce s hodnotou identity jako počáteční hodnotou první fáze.

U třetího přetížení musí být typ hodnoty identity stejný jako typ výsledku redukce, ale iterátor se může lišit od obou. Funkce redukce rozsahu se používá v první fázi s hodnotou identity jako počáteční hodnotou a binární funkce se použije na dílčí výsledky ve druhé fázi.

parallel_sort

Uspořádá prvky v zadaném rozsahu do nesestupné pořadí nebo podle kritéria řazení určeného binárním predikátem paralelně. Tato funkce se sémanticky podobá tím, že se jedná o nestabilní místní řazení založené na porovnávání.

template<typename _Random_iterator>
inline void parallel_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Random_iterator,typename _Function>
inline void parallel_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

Parametry

_Random_iterator
Typ iterátoru vstupního rozsahu.

_Funkce
Typ funktoru binárního porovnání.

_Začít
Iterátor náhodného přístupu adresuje pozici prvního prvku v oblasti, která se má seřadit.

_Konec
Iterátor náhodného přístupu, který adresuje pozici těsně za posledním prvkem v oblasti, která se má seřadit.

_Chunk_size
Minimální velikost bloku dat, která bude rozdělena do dvou pro paralelní provádění.

Poznámky

První přetížení používá binární komparátor .

Druhá přetížená používá zadaný binární komparátor, který by měl mít podpis , kde je typ prvků ve vstupním rozsahu.

paralelní_transformace

Použije zadaný objekt funkce na každý prvek ve zdrojovém rozsahu nebo na dvojici prvků ze dvou zdrojových oblastí a paralelně zkopíruje návratové hodnoty objektu funkce do cílového rozsahu. Tato funkce je sémanticky ekvivalentní .

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    const auto_partitioner& _Part = auto_partitioner());

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    const static_partitioner& _Part);

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    const simple_partitioner& _Part);

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    affinity_partitioner& _Part);

template <typename _Input_iterator1,
    typename _Input_iterator2,
    typename _Output_iterator,
    typename _Binary_operator,
    typename _Partitioner>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Input_iterator2
first2,
    _Output_iterator _Result,
    const _Binary_operator& _Binary_op,
    _Partitioner&& _Part);

template <typename _Input_iterator1,
    typename _Input_iterator2,
    typename _Output_iterator,
    typename _Binary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Input_iterator2
first2,
    _Output_iterator _Result,
    const _Binary_operator& _Binary_op);

Parametry

_Input_iterator1
Typ prvního nebo jediného vstupního iterátoru.

_Output_iterator
Typ výstupního iterátoru.

_Unární_operátor
Typ unárního functoru, který se má provést u každého prvku ve vstupním rozsahu.

_Input_iterator2
Typ druhého vstupního iterátoru.

_Binární_operátor
Typ binárního fuktoru, párově prováděný u prvků ze dvou zdrojových rozsahů.

_Partitioner
první1
Vstupní iterátor adresuje pozici prvního prvku v prvním nebo jediném zdrojovém rozsahu, na který se má pracovat.

poslední 1
Vstupní iterátor adresuje pozici za posledním prvkem v prvním nebo jediném zdrojovém rozsahu, na které se má pracovat.

_Výsledek
Výstupní iterátor adresuje pozici prvního prvku v cílovém rozsahu.

_Unary_op
Objekt unární funkce definovaný uživatelem, který je použit pro každý prvek ve zdrojovém rozsahu.

první2
Vstupní iterátor adresuje pozici prvního prvku ve druhém zdrojovém rozsahu, na který se má pracovat.

_Binary_op
Objekt binární funkce definovaný uživatelem, který se aplikuje spárově, v pořadí vpřed, na dva zdrojové rozsahy.

Návratová hodnota

Výstupní iterátor, který se nachází na pozici těsně za posledním prvkem v cílovém rozsahu, kam jsou přijímány výstupní prvky transformované funkčním objektem.

Poznámky

auto_partitioner bude použit pro přetížení bez explicitního argumentu pro dělení.

Pro iterátory, které nepodporují náhodný přístup, se podporuje pouze auto_partitioner .

Přetížení, která převezmou argument transformují vstupní oblast do výstupní oblasti použitím unárního functoru na každý prvek ve vstupní oblasti. musí podporovat operátor volání funkce s podpisem , kde je typ hodnoty rozsahu, přes který se iteruje.

Přetížení, které přijímají argument , transformují dva vstupní rozsahy na výstupní rozsah použitím binárního funktoru na jeden prvek z prvního vstupního rozsahu a jeden prvek z druhého vstupního rozsahu. musí podporovat operátor volání funkce s podpisem , kde jsou typy hodnot dvou vstupních iterátorů.

Další informace naleznete v tématu Paralelní algoritmy.

přijmout

Obecná implementace příjmu, která umožňuje kontextu čekat na data z přesně jednoho zdroje a filtrovat hodnoty, které jsou přijaty.

template <class T>
T receive(
    _Inout_ ISource<T>* _Src,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

template <class T>
T receive(
    _Inout_ ISource<T>* _Src,
    typename ITarget<T>::filter_method const& _Filter_proc,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

template <class T>
T receive(
    ISource<T>& _Src,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

template <class T>
T receive(
    ISource<T>& _Src,
    typename ITarget<T>::filter_method const& _Filter_proc,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

Parametry

T
Typ užitečného zatížení.

_Src
Ukazatel nebo odkaz na zdroj, ze kterého se očekává data.

_Přerušení zápasu
Maximální doba, po kterou by metoda měla být aplikována na data, v milisekundách.

_Filter_proc
Funkce filtru, která určuje, zda mají být zprávy přijaty.

Návratová hodnota

Hodnota ze zdroje, typu užitečný náklad.

Poznámky

Pokud má parametr jinou hodnotu než konstanta , výjimka operation_timed_out je vyvolán, pokud zadané množství času vyprší před přijetí zprávy. Pokud chcete vypršení časového limitu nulové délky, měli byste použít funkci try_receive, namísto volání funkce s časovým limitem (nulovým), protože je efektivnější a nevyvolává výjimky při vypršení časového limitu.

Další informace naleznete v tématu Funkce předávání zpráv.

run_with_cancellation_token

Provede objekt funkce okamžitě a synchronně v kontextu daného tokenu zrušení.

template<typename _Function>
void run_with_cancellation_token(
    const _Function& _Func,
    cancellation_token _Ct);

Parametry

_Funkce
Typ objektu funkce, který bude vyvolán.

_Func
Objekt funkce, který se spustí. Tento objekt musí podporovat operátor volání funkce s signaturou void(void).

_Ct
Token zrušení, který bude řídit implicitní zrušení objektu funkce. Použijte , pokud chcete, aby se funkce spustila bez jakékoli možnosti implicitního zrušení způsobeného zrušením nadřazené skupiny úloh.

Poznámky

Všechny body přerušení v objektu funkce budou spuštěny, jakmile je zrušeno. Explicitní token izoluje toto od nadřazeného zrušení, pokud má nadřazený objekt jiný token nebo žádný token.

odeslat

Synchronní operace odesílání, která čeká, dokud cíl zprávu přijme nebo odmítne.

template <class T>
bool send(_Inout_ ITarget<T>* _Trg, const T& _Data);

template <class T>
bool send(ITarget<T>& _Trg, const T& _Data);

Parametry

T
Typ užitečného zatížení.

_Trg
Ukazatel nebo odkaz na cíl, na který se data odesílají.

_Data
Odkaz na data, která se mají odeslat.

Návratová hodnota

pokud byla zpráva přijata, jinak.

Poznámky

Další informace naleznete v tématu Funkce předávání zpráv.

set_ambient_scheduler

inline void set_ambient_scheduler(std::shared_ptr<::Concurrency::scheduler_interface> _Scheduler);

Parametry

_Plánovač
Plánovač prostředí, který se má nastavit.

nastavit_zdroje_pro_vykonávání_úloh

Omezuje výpočetní prostředky používané interními pracovními vlákny Concurrency Runtime na určenou sadu afinity.

Tuto metodu lze volat pouze před vytvořením Resource Manageru nebo mezi dvěma životnostmi Resource Manageru. Je možné ji vyvolat vícekrát, pokud Resource Manager v době vyvolání neexistuje. Po nastavení limitu spřažení zůstane v platnosti až do dalšího platného volání metody.

Zadaná maska spřažení nemusí být podmnožinou masky spřažení procesu. Spřažení procesu se v případě potřeby aktualizuje.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

void __cdecl set_task_execution_resources(
    unsigned short count,
    PGROUP_AFFINITY _PGroupAffinity);

Parametry

_ProcessAffinityMask
Maska spřažení, na kterou mají být omezena pracovní vlákna Concurrency Runtime. Tuto metodu použijte v systému s více než 64 hardwarovými vlákny pouze v případě, že chcete omezit modul Concurrency Runtime na podmnožinu aktuální skupiny procesorů. Obecně byste měli použít verzi metody, která přijímá pole spřažení skupin jako parametr, chcete-li omezit spřažení na počítačích s více než 64 hardwarovými vlákny.

počet
Počet položek v poli určeném parametrem .

_PGroupAffinity
Pole záznamů.

Poznámky

Metoda vyvolá výjimku invalid_operation, pokud je v době vyvolání přítomen Resource Manager, a výjimku invalid_argument, pokud zadané spřažení vede k prázdné sadě prostředků.

Verze metody, která jako parametr přebírá pole spřažení skupin, by se měla používat pouze v operačních systémech s verzí Windows 7 nebo vyšší. V opačném případě se vyvolá výjimka invalid_operation.

Programové změny nastavení spřažení procesu po vyvolání této metody nevyvolají přehodnocení omezeného spřažení ze strany Resource Manager. Proto by před voláním této metody měly být provedeny všechny změny ve vazbě procesu.

zaměnit

Vymění prvky dvou objektů.

template<typename T, class _Ax>
inline void swap(
    concurrent_vector<T, _Ax>& _A,
    concurrent_vector<T, _Ax>& _B);

Parametry

T
Datový typ prvků uložených v souběžných vektorech.

_Ax
Typ alokátoru souběžných vektorů.

_A
Souběžný vektor, jehož prvky se mají vyměňovat s prvky souběžného vektoru .

_B
Souběžný vektor poskytující prvky, které mají být prohozeny, nebo vektor, jehož prvky mají být vyměňovány s prvky souběžného vektoru .

Poznámky

Funkce šablony je algoritmus, který je specializován na třídu kontejneru k provedení členské funkce . concurrent_vector::swap(). Jedná se o instance částečného řazení šablon funkcí kompilátorem. Pokud jsou funkce šablony přetíženy takovým způsobem, že shoda šablony s voláním funkce není jedinečná, kompilátor vybere nejspecializovaných verzí funkce šablony. Obecná verze funkce šablony v algoritmu třídy funguje na základě přiřazení, což je pomalá operace. Specializovaná verze v každém kontejneru je mnohem rychlejší, protože dokáže pracovat s interní reprezentací třídy kontejneru.

Tato metoda není bezpečná pro souběžnost. Při volání této metody je nutné zajistit, aby žádné další vlákna prováděla operace s některým ze souběžných vektorů.

task_from_exception

template<typename _TaskType, typename _ExType>
task<_TaskType> task_from_exception(
    _ExType _Exception,
    const task_options& _TaskOptions = task_options());

Parametry

_TaskType

_ExType

_Výjimka

_TaskOptions

Návratová hodnota

úkol_z_výsledku

template<typename T>
task<T> task_from_result(
    T _Param,
    const task_options& _TaskOptions = task_options());

inline task<bool> task_from_result(ool _Param);

inline task<void> task_from_result(
    const task_options& _TaskOptions = task_options());

Parametry

_Param

_TaskOptions

Návratová hodnota

Trace_agenti_registr_název

Přidruží daný název k bloku zprávy nebo agentu v trasování událostí pro Windows.

template <class T>
void Trace_agents_register_name(
    _Inout_ T* _PObject,
    _In_z_ const wchar_t* _Name);

Parametry

T
Typ objektu. Obvykle se jedná o blok zpráv nebo agenta.

_PObject
Ukazatel na blok zprávy nebo agenta, který je pojmenován při sledování.

_Jméno
Název daného objektu.

zkusit_přijmout

Obecná implementace try-receive, která umožňuje kontextu hledat data z přesně jednoho zdroje a filtrovat hodnoty, které jsou přijaty. Pokud data nejsou připravena, metoda vrátí .

template <class T>
bool try_receive(_Inout_ ISource<T>* _Src, T& _value);

template <class T>
bool try_receive(
    _Inout_ ISource<T>* _Src,
    T& _value,
    typename ITarget<T>::filter_method const& _Filter_proc);

template <class T>
bool try_receive(ISource<T>& _Src, T& _value);

template <class T>
bool try_receive(
    ISource<T>& _Src,
    T& _value,
    typename ITarget<T>::filter_method const& _Filter_proc);

Parametry

T
Typ datové části

_Src
Ukazatel nebo odkaz na zdroj, ze kterého se očekává data.

_hodnota
Odkaz na místo, kam bude výsledek uložen.

_Filter_proc
Funkce filtru, která určuje, zda mají být zprávy přijaty.

Návratová hodnota

Hodnota označující, zda byla datová část umístěna do .

Poznámky

Další informace naleznete v tématu Funkce předávání zpráv.

Počkej

Pozastaví aktuální kontext po zadanou dobu.

void __cdecl wait(unsigned int _Milliseconds);

Parametry

_Milisekundy
Počet milisekund, pro který má být aktuální kontext pozastaven. Pokud je parametr nastaven na hodnotu , aktuální kontext by měl před pokračováním přinést spuštění do jiných spustitelných kontextů.

Poznámky

Pokud je tato metoda volána v kontextu plánovače „Concurrency Runtime“, plánovač najde jiný kontext pro spuštění na podkladovém prostředku. Vzhledem k tomu, že plánovač je v podstatě spolupracující, nemůže tento kontext pokračovat přesně po zadaném počtu milisekund. Pokud je plánovač zaneprázdněn prováděním dalších úkolů, které se plánovači nevyrovnávají spolupracujícím způsobem, může být čekací doba neomezená.

when_all

Vytvoří úlohu, která se úspěšně dokončí, když se úspěšně dokončí všechny úkoly zadané jako argumenty.

template <typename _Iterator>
auto when_all(
    _Iterator _Begin,
    _Iterator _End,
    const task_options& _TaskOptions = task_options()) ->
    decltype (details::_WhenAllImpl<typename std::iterator_traits<_Iterator>::value_type::result_type,
    _Iterator>::_Perform(_TaskOptions, _Begin,  _End));

Parametry

_Iterátor
Typ vstupního iterátoru.

_Začít
Pozice prvního prvku v rozsahu prvků, které se mají zkombinovat do výsledného úkolu.

_Konec
Pozice prvního prvku nad rozsah prvků, které se mají zkombinovat do výsledného úkolu.

_TaskOptions
Objekt

Návratová hodnota

Úkol, který se úspěšně dokončí, když byly úspěšně dokončeny všechny vstupní úkoly. Pokud jsou vstupní úkoly typu , výstupem této funkce bude . Pokud jsou vstupní úkoly typu, výstupní úkol bude také .

Poznámky

je neblokující funkce, která jako výsledek vytváří . Na rozdíl od task::wait je bezpečné tuto funkci volat ve vlákně ASTA (Application STA) aplikace UWP.

Pokud je některý z úkolů zrušen nebo vyvolá výjimku, vrácený úkol se dokončí dříve, v zrušeném stavu a výjimka, pokud dojde k některé z nich, bude vyvolána, pokud voláte úkol::get nebo na daném úkolu.

Další informace naleznete v Paralelismu úkolů.

when_any

Vytvoří úlohu, která se úspěšně dokončí, když se úspěšně dokončí některý z úkolů zadaných jako argumenty.

template<typename _Iterator>
auto when_any(
    _Iterator _Begin,
    _Iterator _End,
    const task_options& _TaskOptions = task_options())
    -> decltype (
        details::_WhenAnyImpl<
            typename std::iterator_traits<_Iterator>::value_type::result_type,
            _Iterator>::_Perform(_TaskOptions, _Begin, _End));

template<typename _Iterator>
auto when_any(
    _Iterator _Begin,
    _Iterator _End,
    cancellation_token _CancellationToken)
       -> decltype (
           details::_WhenAnyImpl<
               typename std::iterator_traits<_Iterator>::value_type::result_type,
               _Iterator>::_Perform(_CancellationToken._GetImplValue(), _Begin, _End));

Parametry

_Iterátor
Typ vstupního iterátoru.

_Začít
Pozice prvního prvku v rozsahu prvků, které se mají zkombinovat do výsledného úkolu.

_Konec
Pozice prvního prvku nad rozsah prvků, které se mají zkombinovat do výsledného úkolu.

_TaskOptions
_CancellationToken
Token zrušení, který řídí zrušení vrácené úlohy. Pokud nezadáte token zrušení, výsledná úloha obdrží token zrušení úkolu, který způsobí jeho dokončení.

Návratová hodnota

Úkol, který se úspěšně dokončí, když se úspěšně dokončil některý ze vstupních úkolů. Pokud jsou vstupní úkoly typu , výstupem této funkce bude , kde první prvek dvojice je výsledkem dokončení úkolu a druhý prvek je index dokončeného úkolu. Pokud jsou vstupní úkoly typu , pak je výstup , kde výsledkem je index dokončení úkolu.

Poznámky

je neblokující funkce, která jako výsledek vytváří . Na rozdíl od task::wait je bezpečné tuto funkci volat ve vlákně ASTA (Application STA) aplikace UWP.

Další informace naleznete v Paralelismu úkolů.

Viz také

concurrency – obor názvů

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-03-06