funktioner för samtidighetsnamnområde

Artikel
2025-02-04

Alloc

Allokerar ett block med minne av den storlek som anges från concurrency Runtime Caching Suballocator.

void* __cdecl Alloc(size_t _NumBytes);

Parametrar

_NumBytes
Antalet byte minne som ska allokeras.

Returvärde

En pekare till nyligen allokerat minne.

Anmärkningar

Mer information om vilka scenarier i ditt program som kan dra nytta av att använda cachelagringsunderlokaliseraren finns i Task Scheduler.

asend

En asynkron sändningsåtgärd som schemalägger en uppgift för att sprida data till målblocket.

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

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

Parametrar

T
Typen av data som ska skickas.

_Trg
En pekare eller referens till målet som data skickas till.

_Data
En referens till de data som ska skickas.

Returvärde

true om meddelandet accepterades innan metoden returnerades false annars.

Anmärkningar

Mer information finns i Message Passing Functions.

cancel_current_task

Avbryter den uppgift som körs just nu. Den här funktionen kan anropas inifrån en aktivitets brödtext för att avbryta körningen av aktiviteten och få den att ange canceled tillstånd.

Det är inte ett scenario som stöds för att anropa den här funktionen om du inte befinner dig i brödtexten i en task. Om du gör det resulterar det i odefinierat beteende, till exempel en krasch eller att programmet inte svarar.

inline __declspec(noreturn) void __cdecl cancel_current_task();

klar

Rensar den samtidiga kön och förstör alla element som är aktuella. Den här metoden är inte samtidighetssäker.

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

Parametrar

_Ax

create_async

Skapar en asynkron Windows Runtime-konstruktion baserat på en lambda- eller funktionsobjekt från användaren. Returtypen för create_async är antingen IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^eller IAsyncOperationWithProgress<TResult, TProgress>^ baserat på signaturen för lambda som skickas till metoden.

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

Parametrar

_Function
Typ.

_Func
Lambda- eller funktionsobjektet som du vill skapa en asynkron Windows Runtime-konstruktion från.

Returvärde

En asynkron konstruktion som representeras av en IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^, eller en IAsyncOperationWithProgress<TResult, TProgress>^. Gränssnittet som returneras beror på signaturen för lambda som skickas till funktionen.

Anmärkningar

Returtypen för lambda avgör om konstruktionen är en åtgärd eller en åtgärd.

Lambdas som returnerar tomrum orsakar skapandet av åtgärder. Lambdas som returnerar ett resultat av typen TResult orsaka skapandet av TResult-åtgärder.

Lambda kan också returnera en task<TResult> som kapslar in det aysnchroniska arbetet i sig eller är en fortsättning på en kedja av uppgifter som representerar det asynkrona arbetet. I det här fallet körs lambda självt infogat, eftersom uppgifterna är de som körs asynkront, och returtypen för lambda packas upp för att producera den asynkrona konstruktionen som returneras av create_async. Detta innebär att en lambda som returnerar en uppgift<tomrum> kommer att orsaka skapandet av åtgärder, och en lambda som returnerar en uppgift<TResult> kommer att orsaka skapandet av TResult-åtgärder.

Lambda kan ta antingen noll, ett eller två argument. Giltiga argument är progress_reporter<TProgress> och cancellation_token, i den ordningen om båda används. En lambda utan argument gör att en asynkron konstruktion skapas utan funktionen för förloppsrapportering. En lambda som tar en progress_reporter<TProgress-> gör att create_async returnerar en asynkron konstruktion som rapporterar förlopp av typen TProgress varje gång report-metoden för progress_reporter-objektet anropas. En lambda som tar en cancellation_token kan använda den token för att söka efter annullering eller skicka den till uppgifter som den skapar så att annulleringen av den asynkrona konstruktionen orsakar annullering av dessa uppgifter.

Om brödtexten i lambda- eller funktionsobjektet returnerar ett resultat (och inte en uppgift<TResult>), körs lamdba asynkront i processens MTA i kontexten för en aktivitet som Runtime implicit skapar för den. Metoden IAsyncInfo::Cancel orsakar annullering av den implicita aktiviteten.

Om lambda-brödtexten returnerar en aktivitet körs lamba infogat och genom att deklarera lambda att ta ett argument av typen cancellation_token kan du utlösa annullering av alla aktiviteter som du skapar i lambda genom att skicka in token när du skapar dem. Du kan också använda metoden register_callback på token för att få Runtime att anropa ett återanrop när du anropar IAsyncInfo::Cancel på den asynkrona åtgärd som skapats.

Den här funktionen är endast tillgänglig för Windows Runtime-appar.

CreateResourceManager

Returnerar ett gränssnitt som representerar singleton-instansen av Concurrency Runtimes Resource Manager. Resource Manager ansvarar för att tilldela resurser till schemaläggare som vill samarbeta med varandra.

IResourceManager* __cdecl CreateResourceManager();

Returvärde

Ett IResourceManager gränssnitt.

Anmärkningar

Flera efterföljande anrop till den här metoden returnerar samma instans av Resource Manager. Varje anrop till metoden ökar ett referensantal för Resource Manager och måste matchas med ett anrop till metoden IResourceManager::Release när schemaläggaren är klar med kommunikationen med Resource Manager.

unsupported_os genereras om operativsystemet inte stöds av Concurrency Runtime.

create_task

Skapar en PPL-uppgift objekt. create_task kan användas var som helst där du skulle ha använt en aktivitetskonstruktor. Det tillhandahålls främst för enkelhetens skull, eftersom det tillåter användning av nyckelordet auto när uppgifter skapas.

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

Parametrar

T
Typen av parameter som uppgiften ska konstrueras från.

_ReturnType
Typ.

_Param
Parametern som uppgiften ska konstrueras från. Det kan vara ett lambda- eller funktionsobjekt, ett task_completion_event objekt, ett annat task-objekt eller ett Windows::Foundation::IAsyncInfo-gränssnitt om du använder uppgifter i UWP-appen.

_TaskOptions
Aktivitetsalternativen.

_Task
Uppgiften som ska skapas.

Returvärde

En ny uppgift av typen T, som härleds från _Param.

Anmärkningar

Den första överlagringen fungerar som en aktivitetskonstruktor som tar en enda parameter.

Den andra överlagringen associerar den annulleringstoken som tillhandahålls med den nyligen skapade aktiviteten. Om du använder den här överlagringen får du inte skicka in ett annat task objekt som den första parametern.

Typen av den returnerade aktiviteten härleds från den första parametern till funktionen. Om _Param är en task_completion_event<T>, en task<T>eller en functor som returnerar antingen typ T eller task<T>, är typen av den skapade aktiviteten task<T>.

Om _Param i en UWP-app är av typen Windows::Foundation::IAsyncOperation<T>^ eller Windows::Foundation::IAsyncOperationWithProgress<T,P>^, eller en functor som returnerar någon av dessa typer, kommer den skapade uppgiften att vara av typen task<T>. Om _Param är av typen Windows::Foundation::IAsyncAction^ eller Windows::Foundation::IAsyncActionWithProgress<P>^, eller en functor som returnerar någon av dessa typer, har den skapade aktiviteten typ task<void>.

DisableTracing

Inaktiverar spårning i Concurrency Runtime. Den här funktionen är inaktuell eftersom ETW-spårning avregistreras som standard.

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

Returvärde

Om spårningen har inaktiverats korrekt returneras S_OK. Om spårning inte har initierats tidigare returneras E_NOT_STARTED

EnableTracing

Aktiverar spårning i Concurrency Runtime. Den här funktionen är inaktuell eftersom ETW-spårning nu är aktiverat som standard.

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

Returvärde

Om spårningen initierades korrekt returneras S_OK. annars returneras E_NOT_STARTED.

Gratis

Frigör ett minnesblock som tidigare allokerats av metoden Alloc till concurrency Runtime Caching Suballocator.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

Parametrar

_PAllocation
En pekare till minne som tidigare allokerats av metoden Alloc som ska frigöras. Om parametern _PAllocation är inställd på värdet NULLignoreras den här metoden och returneras omedelbart.

Anmärkningar

Mer information om vilka scenarier i ditt program som kan dra nytta av att använda cachelagringsunderlokaliseraren finns i Task Scheduler.

get_ambient_scheduler

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

Returvärde

GetExecutionContextId

Returnerar en unik identifierare som kan tilldelas till en körningskontext som implementerar IExecutionContext-gränssnittet.

unsigned int __cdecl GetExecutionContextId();

Returvärde

En unik identifierare för en körningskontext.

Anmärkningar

Använd den här metoden för att hämta en identifierare för körningskontexten innan du skickar ett IExecutionContext-gränssnitt som en parameter till någon av de metoder som erbjuds av Resource Manager.

GetOSVersion

Returnerar operativsystemversionen.

IResourceManager::OSVersion __cdecl GetOSVersion();

Returvärde

Ett uppräknat värde som representerar operativsystemet.

Anmärkningar

unsupported_os genereras om operativsystemet inte stöds av Concurrency Runtime.

GetProcessorCount

Returnerar antalet maskinvarutrådar i det underliggande systemet.

unsigned int __cdecl GetProcessorCount();

Returvärde

Antalet maskinvarutrådar.

Anmärkningar

unsupported_os genereras om operativsystemet inte stöds av Concurrency Runtime.

GetProcessorNodeCount

Returnerar antalet NUMA-noder eller processorpaket i det underliggande systemet.

unsigned int __cdecl GetProcessorNodeCount();

Returvärde

Antalet NUMA-noder eller processorpaket.

Anmärkningar

Om systemet innehåller fler NUMA-noder än processorpaket returneras antalet NUMA-noder, annars returneras antalet processorpaket.

unsupported_os genereras om operativsystemet inte stöds av Concurrency Runtime.

GetSchedulerId

Returnerar en unik identifierare som kan tilldelas till en schemaläggare som implementerar IScheduler-gränssnittet.

unsigned int __cdecl GetSchedulerId();

Returvärde

En unik identifierare för en schemaläggare.

Anmärkningar

Använd den här metoden för att hämta en identifierare för schemaläggaren innan du skickar ett IScheduler-gränssnitt som en parameter till någon av de metoder som erbjuds av 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);

Parametrar

_Ax

första

senaste

interruption_point

Skapar en avbrottspunkt för annullering. Om en annullering pågår i kontexten där den här funktionen anropas utlöser detta ett internt undantag som avbryter körningen av det parallella arbete som körs just nu. Om annulleringen inte pågår gör funktionen ingenting.

inline void interruption_point();

Anmärkningar

Du bör inte fånga det interna annulleringsfel som utlöses av funktionen interruption_point(). Undantaget fångas och hanteras av körningen, och om du fångar det kan det leda till att programmet beter sig onormalt.

is_current_task_group_canceling

Returnerar en indikation på om den aktivitetsgrupp som för närvarande körs infogat i den aktuella kontexten befinner sig mitt i en aktiv annullering (eller kommer att vara inom kort). Observera att om det inte finns någon aktivitetsgrupp som körs infogat i den aktuella kontexten returneras false.

bool __cdecl is_current_task_group_canceling();

Returvärde

true om aktivitetsgruppen som körs just nu avbryts false annars.

Anmärkningar

Mer information finns i Annullering.

make_choice

Skapar ett choice meddelandeblock från en valfri Scheduler eller ScheduleGroup och två eller flera indatakällor.

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

Parametrar

T1
Meddelandeblockstypen för den första källan.

T2
Meddelandeblockstypen för den andra källan.

_PScheduler
Det Scheduler objekt inom vilket spridningsaktiviteten för choice meddelandeblock har schemalagts.

_Item1
Den första källan.

_Item2
Den andra källan.

_Items
Ytterligare källor.

_PScheduleGroup
Det ScheduleGroup objekt inom vilket spridningsaktiviteten för choice meddelandeblock har schemalagts. Det Scheduler objekt som används underförstås av schemagruppen.

Returvärde

Ett choice meddelandeblock med två eller flera indatakällor.

make_greedy_join

Skapar ett greedy multitype_join meddelandeblock från en valfri Scheduler eller ScheduleGroup och två eller flera indatakällor.

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

Parametrar

T1
Meddelandeblockstypen för den första källan.

T2
Meddelandeblockstypen för den andra källan.

_PScheduler
Det Scheduler objekt inom vilket spridningsaktiviteten för multitype_join meddelandeblock har schemalagts.

_Item1
Den första källan.

_Item2
Den andra källan.

_Items
Ytterligare källor.

_PScheduleGroup
Det ScheduleGroup objekt inom vilket spridningsaktiviteten för multitype_join meddelandeblock har schemalagts. Det Scheduler objekt som används underförstås av schemagruppen.

Returvärde

Ett greedy multitype_join meddelandeblock med två eller flera indatakällor.

make_join

Skapar ett non_greedy multitype_join meddelandeblock från en valfri Scheduler eller ScheduleGroup och två eller flera indatakällor.

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

Parametrar

T1
Meddelandeblockstypen för den första källan.

T2
Meddelandeblockstypen för den andra källan.

_PScheduler
Det Scheduler objekt inom vilket spridningsaktiviteten för multitype_join meddelandeblock har schemalagts.

_Item1
Den första källan.

_Item2
Den andra källan.

_Items
Ytterligare källor.

Returvärde

Ett non_greedy multitype_join meddelandeblock med två eller flera indatakällor.

make_task

En fabriksmetod för att skapa ett task_handle objekt.

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

Parametrar

_Function
Typen av funktionsobjekt som ska anropas för att köra det arbete som representeras av task_handle-objektet.

_Func
Den funktion som ska anropas för att köra det arbete som representeras av task_handle-objektet. Det kan vara en lambda-functor, en pekare till en funktion eller ett objekt som stöder en version av funktionsanropsoperatorn med signaturen void operator()().

Returvärde

Ett task_handle objekt.

Anmärkningar

Den här funktionen är användbar när du behöver skapa ett task_handle objekt med ett lambda-uttryck, eftersom det gör att du kan skapa objektet utan att känna till den sanna typen av lambda-functor.

parallel_buffered_sort

Ordnar elementen i ett angivet intervall i en icke-fallande ordning, eller enligt ett ordningsvillkor som anges av ett binärt predikat parallellt. Den här funktionen liknar semantiskt std::sort eftersom den är en jämförelsebaserad, instabil sortering på plats förutom att den behöver O(n) ytterligare utrymme och kräver standardinitiering för de element som sorteras.

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

Parametrar

_Random_iterator
Iteratortypen för indataområdet.

_Allocator
Typ av en C++-standardbibliotekskompatibel minnesallokering.

_Function
Typ av binär jämförelse.

_Begin
En iterator med slumpmässig åtkomst som hanterar positionen för det första elementet i intervallet som ska sorteras.

_End
En iterator med slumpmässig åtkomst som adresserar positionen förbi det sista elementet i intervallet som ska sorteras.

_Alloc
En instans av en C++-standardbibliotekskompatibel minnesallokering.

_Func
Ett användardefinierat predikatfunktionsobjekt som definierar jämförelsekriteriet som ska uppfyllas av efterföljande element i ordningen. Ett binärt predikat tar två argument och returnerar true när det är uppfyllt och false när det inte är uppfyllt. Den här jämförelsefunktionen måste införa en strikt svag ordning på par av element från sekvensen.

_Chunk_size
Mimimumstorleken för ett segment som delas upp i två för parallell körning.

Anmärkningar

Alla överlagringar kräver n * sizeof(T) ytterligare utrymme, där n är antalet element som ska sorteras och T är elementtypen. I de flesta fall visar parallel_buffered_sort prestandaförbättringar jämfört med parallel_sort, och du bör använda den över parallel_sort om du har tillgängligt minne.

Om du inte anger en binär jämförelse std::less används som standard, vilket kräver att elementtypen anger operatorn operator<().

Om du inte anger någon allokeringstyp eller instans används minnesallokeraren C++ Standard Library std::allocator<T> för att allokera bufferten.

Algoritmen delar indataområdet i två segment och delar sedan upp varje segment i två delsegment för körning parallellt. Det valfria argumentet _Chunk_size kan användas för att ange för algoritmen att den ska hantera segment av storlek <_Chunk_size seriellt.

parallel_for

parallel_for itererar över ett antal index och kör en användartillämpad funktion vid varje iteration parallellt.

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

Parametrar

_Index_type
Typen av index som används för iterationen.

_Function
Den typ av funktion som ska köras vid varje iteration.

_Partitioner
Typen av partitionerare som används för att partitionering av det angivna intervallet.

första
Det första indexet som ska ingå i iterationen.

senaste
Indexet ett förbi det sista indexet som ska inkluderas i iterationen.

_Step
Värdet som du ska stega efter när du itererar från first till last. Steget måste vara positivt. invalid_argument utlöses om steget är mindre än 1.

_Func
Den funktion som ska köras vid varje iteration. Det kan vara ett lambda-uttryck, en funktionspekare eller ett objekt som stöder en version av funktionsanropsoperatorn med signaturen void operator()(_Index_type).

_Part
En referens till partitioneringsobjektet. Argumentet kan vara ett av constauto_partitioner&, conststatic_partitioner&, constsimple_partitioner& eller affinity_partitioner& Om ett affinity_partitioner objekt används måste referensen vara en referens som inte är en l-värdereferens, så att algoritmen kan lagra tillstånd för framtida loopar att återanvända.

Anmärkningar

Mer information finns i parallella algoritmer.

parallel_for_each

parallel_for_each tillämpar en angiven funktion på varje element inom ett intervall parallellt. Den är semantiskt likvärdig med funktionen for_each i std namnrymd, förutom att iteration över elementen utförs parallellt och iterationens ordning är ospecificerad. Argumentet _Func måste ha stöd för en funktionsanropsoperator för formuläret operator()(T) där parametern T är objekttypen för containern som itereras över.

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

Parametrar

_Iterator
Typen av iterator som används för att iterera över containern.

_Function
Typen av funktion som ska tillämpas på varje element inom intervallet.

_Partitioner
första
En iterator som hanterar positionen för det första elementet som ska ingå i parallell iteration.

senaste
En iterator som hanterar positionen en förbi det sista elementet som ska ingå i parallell iteration.

_Func
Ett användardefinierat funktionsobjekt som tillämpas på varje element i intervallet.

Anmärkningar

auto_partitioner används för överlagringen utan en explicit partitionerare.

För iteratorer som inte stöder slumpmässig åtkomst stöds endast auto_partitioner.

Mer information finns i parallella algoritmer.

parallel_invoke

Kör funktionsobjekten som anges som parametrar parallellt och blockerar tills de har körts klart. Varje funktionsobjekt kan vara ett lambda-uttryck, en pekare som ska fungera eller ett objekt som stöder funktionsanropsoperatorn med signaturen void operator()().

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

Parametrar

_Function1
Typ av det första funktionsobjektet som ska köras parallellt.

_Function2
Typ av det andra funktionsobjektet som ska köras parallellt.

_Function3
Typ av det tredje funktionsobjektet som ska köras parallellt.

_Function4
Typen av det fjärde funktionsobjektet som ska köras parallellt.

_Function5
Typ av det femte funktionsobjektet som ska köras parallellt.

_Function6
Typ av det sjätte funktionsobjektet som ska köras parallellt.

_Function7
Typen av det sjunde funktionsobjektet som ska köras parallellt.

_Function8
Typ av det åttonde funktionsobjektet som ska köras parallellt.

_Function9
Typen av det nionde funktionsobjekt som ska köras parallellt.

_Function10
Typ av det tionde funktionsobjektet som ska köras parallellt.

_Func1
Det första funktionsobjektet som ska köras parallellt.

_Func2
Det andra funktionsobjektet som ska köras parallellt.

_Func3
Det tredje funktionsobjektet som ska köras parallellt.

_Func4
Det fjärde funktionsobjektet som ska köras parallellt.

_Func5
Det femte funktionsobjektet som ska köras parallellt.

_Func6
Det sjätte funktionsobjektet som ska köras parallellt.

_Func7
Det sjunde funktionsobjektet som ska köras parallellt.

_Func8
Det åttonde funktionsobjektet som ska köras parallellt.

_Func9
Det nionde funktionsobjektet som ska köras parallellt.

_Func10
Det tionde funktionsobjektet som ska köras parallellt.

Anmärkningar

Observera att ett eller flera av de funktionsobjekt som anges som parametrar kan köras infogat i den anropande kontexten.

Om ett eller flera av funktionsobjekten som skickas som parametrar till den här funktionen genererar ett undantag, väljer körningen ett sådant undantag som det väljer och sprider det från anropet till parallel_invoke.

Mer information finns i parallella algoritmer.

parallel_radixsort

Ordnar element i ett angivet intervall i en icke fallande ordning med hjälp av en radixsorteringsalgoritm. Det här är en stabil sorteringsfunktion som kräver en projektionsfunktion som kan projicera element som ska sorteras i osignerade heltalsliknande nycklar. Standardinitiering krävs för de element som sorteras.

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

Parametrar

_Random_iterator
Iteratortypen för indataområdet.

_Allocator
Typ av en C++-standardbibliotekskompatibel minnesallokering.

_Function
Typen av projektionsfunktion.

_Begin
En iterator med slumpmässig åtkomst som hanterar positionen för det första elementet i intervallet som ska sorteras.

_End
En iterator med slumpmässig åtkomst som adresserar positionen förbi det sista elementet i intervallet som ska sorteras.

_Alloc
En instans av en C++-standardbibliotekskompatibel minnesallokering.

_Proj_func
Ett användardefinierat projektionsfunktionsobjekt som konverterar ett element till ett integralvärde.

_Chunk_size
Mimimumstorleken för ett segment som delas upp i två för parallell körning.

Anmärkningar

Alla överlagringar kräver n * sizeof(T) ytterligare utrymme, där n är antalet element som ska sorteras och T är elementtypen. En unary-projektionspraktor med signaturen I _Proj_func(T) krävs för att returnera en nyckel när ett element anges, där T är elementtypen och I är en heltalsliknande typ som inte är signerad.

Om du inte anger en projektionsfunktion används en standardprojektionsfunktion som helt enkelt returnerar elementet för integraltyper. Funktionen kan inte kompileras om elementet inte är en integrerad typ i avsaknad av en projektionsfunktion.

Om du inte anger någon allokeringstyp eller instans används minnesallokeraren C++ Standard Library std::allocator<T> för att allokera bufferten.

parallel_reduce

Beräknar summan av alla element i ett angivet intervall genom att beräkna successiva partiella summor, eller beräknar resultatet av efterföljande partiella resultat som på liknande sätt erhålls från att använda en angiven binär åtgärd förutom summa, parallellt. parallel_reduce är semantiskt likt std::accumulate, förutom att den kräver att den binära åtgärden är associativ och kräver ett identitetsvärde i stället för ett initialt värde.

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

Parametrar

_Forward_iterator
Iteratortypen för indataintervallet.

_Sym_reduce_fun
Typen av den symmetriska reduktionsfunktionen. Detta måste vara en funktionstyp med signaturen _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type), där _Reduce_type är samma som identitetstypen och resultattypen för minskningen. För den tredje överlagringen bör detta vara konsekvent med utdatatypen för _Range_reduce_fun.

_Reduce_type
Den typ som indata kommer att minska till, vilket kan skilja sig från indataelementtypen. Returvärdet och identitetsvärdet har den här typen.

_Range_reduce_fun
Typ av intervallreduktionsfunktion. Detta måste vara en funktionstyp med signaturen _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type), _Reduce_type är samma som identitetstypen och resultattypen för minskningen.

_Begin
En iterator för indata som adresserar det första elementet i intervallet som ska minskas.

_End
En indata iterator som behandlar elementet som är en position utöver det sista elementet i intervallet som ska minskas.

_Identity
Identitetsvärdet _Identity är av samma typ som resultattypen för minskningen och även iteratorns value_type för den första och andra överbelastningen. För den tredje överlagringen måste identitetsvärdet ha samma typ som resultattypen för minskningen, men kan skilja sig från iteratorns value_type. Det måste ha ett lämpligt värde så att intervallreduktionsoperatorn _Range_fun, när den tillämpas på ett intervall av ett enda element av typen value_type och identitetsvärdet, fungerar som en typuppsättning av värdet från typ value_type till identitetstyp.

_Sym_fun
Den symmetriska funktion som ska användas i den andra av reduktionen. Mer information finns i Kommentarer.

_Range_fun
Den funktion som ska användas i den första fasen av minskningen. Mer information finns i Kommentarer.

Returvärde

Resultatet av minskningen.

Anmärkningar

För att utföra en parallell minskning delar funktionen upp intervallet i segment baserat på antalet arbetare som är tillgängliga för den underliggande schemaläggaren. Minskningen sker i två faser, den första fasen utför en minskning inom varje segment och den andra fasen utför en minskning mellan de partiella resultaten från varje segment.

Den första överlagringen kräver att iteratorns value_type, T, är samma som identitetsvärdetypen samt resultattypen för minskning. Elementtypen T måste ange operatorn T T::operator + (T) för att minska elementen i varje segment. Samma operator används även i den andra fasen.

Den andra överlagringen kräver också att iteratorns value_type vara samma som identitetsvärdetypen samt resultattypen för minskning. Den angivna binära operatorn _Sym_fun används i båda minskningsfaserna, med identitetsvärdet som initialvärde för den första fasen.

För den tredje överlagringen måste identitetsvärdetypen vara samma som minskningsresultattypen, men iteratorns value_type kan skilja sig från båda. Funktionen för intervallreduktion _Range_fun används i den första fasen med identitetsvärdet som initialvärde, och den binära funktionen _Sym_reduce_fun tillämpas på underresultat i den andra fasen.

parallel_sort

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

Parametrar

_Random_iterator
Iteratortypen för indataområdet.

_Function
Typ av binär jämförelsespraktor.

_Begin
En iterator med slumpmässig åtkomst som hanterar positionen för det första elementet i intervallet som ska sorteras.

_End
En iterator med slumpmässig åtkomst som adresserar positionen förbi det sista elementet i intervallet som ska sorteras.

_Chunk_size
Den minsta storleken på ett segment som ska delas upp i två för parallell körning.

Anmärkningar

Den första överlagringen använder den binära jämförelsen std::less.

Den andra överlagrade använder den angivna binära jämförelsen som ska ha signaturen bool _Func(T, T) där T är typen av element i indataområdet.

parallel_transform

Tillämpar ett angivet funktionsobjekt på varje element i ett källintervall, eller på ett par element från två källintervall, och kopierar returvärdena för funktionsobjektet till ett målintervall parallellt. Den här funktionen motsvarar semantiskt std::transform.

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

Parametrar

_Input_iterator1
Typ av den första eller enda indata-iteratorn.

_Output_iterator
Typ av iterator för utdata.

_Unary_operator
Den typ av unary-functor som ska köras på varje element i indataområdet.

_Input_iterator2
Typ av iterator för andra indata.

_Binary_operator
Typen av binär functor som körs parvis på element från de två källintervallen.

_Partitioner
första1
En indata iterator som hanterar positionen för det första elementet i det första eller enda källintervallet som ska köras på.

senaste1
En indata iterator som hanterar positionen en förbi det sista elementet i det första eller enda källintervallet som ska köras på.

_Result
En iterator för utdata som hanterar positionen för det första elementet i målintervallet.

_Unary_op
Ett användardefinierat unary-funktionsobjekt som tillämpas på varje element i källområdet.

första2
En indata iterator som hanterar positionen för det första elementet i det andra källintervallet som ska köras på.

_Binary_op
Ett användardefinierat binärt funktionsobjekt som tillämpas parvis, i vidarebefordrad ordning, på de två källintervallen.

Returvärde

En iterator för utdata som adresserar positionen förbi det sista elementet i målintervallet som tar emot utdataelementen som transformeras av funktionsobjektet.

Anmärkningar

auto_partitioner används för överlagringar utan ett explicit partitionerargument.

För iteratorer som inte stöder slumpmässig åtkomst stöds endast auto_partitioner.

De överlagringar som tar argumentet _Unary_op omvandla indataområdet till utdataområdet genom att tillämpa den unary-functor på varje element i indataområdet. _Unary_op måste ha stöd för funktionsanropsoperatorn med signatur operator()(T) där T är värdetypen för det intervall som itereras över.

De överlagringar som tar argumentet _Binary_op omvandla två indataintervall till utdataområdet genom att tillämpa den binära kultorn på ett element från det första indataintervallet och ett element från det andra indataintervallet. _Binary_op måste ha stöd för funktionsanropsoperatorn med signatur operator()(T, U) där T, U är värdetyper för de två indata iteratorerna.

Mer information finns i parallella algoritmer.

mottaga

En allmän implementering av mottagningen, vilket gör att en kontext kan vänta på data från exakt en källa och filtrera de värden som accepteras.

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

Parametrar

T
Nyttolasttypen.

_Src
En pekare eller referens till den källa som data förväntas från.

_Timeout
Den maximala tid för vilken metoden ska för data, i millisekunder.

_Filter_proc
En filterfunktion som avgör om meddelanden ska godkännas.

Returvärde

Ett värde från källan, av nyttolasttypen.

Anmärkningar

Om parametern _Timeout har ett annat värde än konstanten COOPERATIVE_TIMEOUT_INFINITEutlöses undantaget operation_timed_out om den angivna tiden upphör att gälla innan ett meddelande tas emot. Om du vill ha en tidsgräns på noll längd bör du använda funktionen try_receive i stället för att anropa receive med en tidsgräns på 0 (noll), eftersom den är mer effektiv och inte utlöser undantag vid tidsgränser.

Mer information finns i Message Passing Functions.

run_with_cancellation_token

Kör ett funktionsobjekt omedelbart och synkront i kontexten för en viss annulleringstoken.

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

Parametrar

_Function
Typ av funktionsobjekt som ska anropas.

_Func
Funktionsobjektet som ska köras. Det här objektet måste ha stöd för funktionsanropsoperatorn med signaturen void(void).

_Ct
Annulleringstoken som styr implicit annullering av funktionsobjektet. Använd cancellation_token::none() om du vill att funktionen ska köras utan möjlighet till implicit annullering från en överordnad aktivitetsgrupp som avbryts.

Anmärkningar

Avbrottspunkter i funktionsobjektet utlöses när cancellation_token avbryts. Den explicita token _Ct isolerar den här _Func från överordnad annullering om den överordnade har en annan token eller ingen token.

sända

En synkron sändningsåtgärd som väntar tills målet antingen accepterar eller avvisar meddelandet.

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

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

Parametrar

T
Nyttolasttypen.

_Trg
En pekare eller referens till målet som data skickas till.

_Data
En referens till de data som ska skickas.

Returvärde

true om meddelandet accepterades false annat.

Anmärkningar

Mer information finns i Message Passing Functions.

set_ambient_scheduler

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

Parametrar

_Scheduler
Den omgivande schemaläggaren som ska anges.

set_task_execution_resources

Begränsar körningsresurserna som används av concurrency Runtime interna arbetstrådar till den angivna tillhörighetsuppsättningen.

Det är giltigt att anropa den här metoden endast innan Resource Manager har skapats eller mellan två Resource Manager-livslängder. Det kan anropas flera gånger så länge Resource Manager inte finns vid tidpunkten för anropet. När en tillhörighetsgräns har angetts gäller den tills nästa giltiga anrop till metoden set_task_execution_resources.

Den angivna tillhörighetsmasken behöver inte vara en delmängd av processtillhörighetsmasken. Processtillhörigheten uppdateras om det behövs.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

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

Parametrar

_ProcessAffinityMask
Den tillhörighetsmask som concurrency Runtime-arbetstrådarna ska begränsas till. Använd den här metoden i ett system med fler än 64 maskinvarutrådar endast om du vill begränsa Samtidighetskörning till en delmängd av den aktuella processorgruppen. I allmänhet bör du använda den version av metoden som accepterar en matris med grupptillhörigheter som en parameter för att begränsa tillhörigheten på datorer med fler än 64 maskinvarutrådar.

antal
Antalet GROUP_AFFINITY poster i matrisen som anges av parametern _PGroupAffinity.

_PGroupAffinity
En matris med GROUP_AFFINITY poster.

Anmärkningar

Metoden utlöser ett invalid_operation undantag om en Resource Manager finns vid den tidpunkt då den anropas och ett invalid_argument undantag om den angivna tillhörigheten resulterar i en tom uppsättning resurser.

Den version av metoden som använder en matris med grupptillhörigheter som en parameter bör endast användas på operativsystem med version Windows 7 eller senare. Annars utlöses ett invalid_operation undantag.

Programmatiskt ändring av processtillhörigheten efter att den här metoden har anropats gör inte att Resource Manager utvärderar om tillhörigheten som den är begränsad till. Därför bör alla ändringar i processtillhörigheten göras innan du anropar den här metoden.

byta

Utbyter elementen i två concurrent_vector objekt.

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

Parametrar

T
Datatypen för de element som lagras i de samtidiga vektorerna.

_Ax
Allokeringstypen för de samtidiga vektorerna.

_A
Den samtidiga vektor vars element ska bytas ut mot den samtidiga vektorns _B.

_B
Den samtidiga vektorn som tillhandahåller de element som ska bytas ut, eller den vektor vars element ska bytas ut mot den samtidiga vektorns _A.

Anmärkningar

Mallfunktionen är en algoritm som är specialiserad på containerklassen concurrent_vector för att köra medlemsfunktionen _A. concurrent_vector::swap( _B). Det här är instanser av den partiella ordningen på funktionsmallar av kompilatorn. När mallfunktioner överbelastas på ett sådant sätt att matchningen av mallen med funktionsanropet inte är unik väljer kompilatorn den mest specialiserade versionen av mallfunktionen. Den allmänna versionen av mallfunktionen, template <class T> void swap(T&, T&), i algoritmklassen fungerar efter tilldelning och är en långsam åtgärd. Den specialiserade versionen i varje container går mycket snabbare eftersom den kan fungera med den interna representationen av containerklassen.

Den här metoden är inte samtidighetssäker. Du måste se till att inga andra trådar utför åtgärder på någon av de samtidiga vektorerna när du anropar den här metoden.

task_from_exception

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

Parametrar

_TaskType

_ExType

_Exception

_TaskOptions

Returvärde

task_from_result

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

Parametrar

_Param

_TaskOptions

Returvärde

Trace_agents_register_name

Associerar det angivna namnet till meddelandeblocket eller agenten i ETW-spårningen.

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

Parametrar

T
Typ av objekt. Detta är vanligtvis ett meddelandeblock eller en agent.

_PObject
En pekare till meddelandeblocket eller agenten som namnges i spårningen.

_Name
Namnet på det angivna objektet.

try_receive

En allmän try-receive-implementering som gör att en kontext kan söka efter data från exakt en källa och filtrera de värden som accepteras. Om data inte är klara returnerar metoden false.

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

Parametrar

T
Nyttolasttypen

_Src
En pekare eller referens till den källa som data förväntas från.

_value
En referens till en plats där resultatet kommer att placeras.

_Filter_proc
En filterfunktion som avgör om meddelanden ska godkännas.

Returvärde

Ett bool värde som anger om en nyttolast har placerats i _value.

Anmärkningar

Mer information finns i Message Passing Functions.

Vänta

Pausar den aktuella kontexten under en angiven tidsperiod.

void __cdecl wait(unsigned int _Milliseconds);

Parametrar

_Milliseconds
Antalet millisekunder som den aktuella kontexten ska pausas för. Om parametern _Milliseconds är inställd på värdet 0ska den aktuella kontexten ge körning till andra körbara kontexter innan du fortsätter.

Anmärkningar

Om den här metoden anropas i en Concurrency Runtime-schemaläggarkontext hittar schemaläggaren en annan kontext som ska köras på den underliggande resursen. Eftersom schemaläggaren är samarbetsinriktad kan den här kontexten inte återupptas exakt efter det antal millisekunder som angetts. Om schemaläggaren är upptagen med att utföra andra uppgifter som inte kooperativt ger efter för schemaläggaren kan väntetiden vara obegränsad.

when_all

Skapar en uppgift som slutförs när alla uppgifter som anges som argument har slutförts.

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

Parametrar

_Iterator
Typ av iterator för indata.

_Begin
Positionen för det första elementet i elementintervallet som ska kombineras till den resulterande aktiviteten.

_End
Positionen för det första elementet utanför det område av element som ska kombineras till den resulterande aktiviteten.

_TaskOptions
Objektet task_options.

Returvärde

En uppgift som slutförs när alla indataaktiviteter har slutförts. Om indatauppgifterna är av typen Tblir utdata för den här funktionen en task<std::vector<T>>. Om indatauppgifterna är av typen void blir utdataaktiviteten också en task<void>.

Anmärkningar

when_all är en icke-blockerande funktion som skapar en task som resultat. Till skillnad från uppgift::väntaär det säkert att anropa den här funktionen i en UWP-app i ASTA-tråden (Application STA).

Om en av aktiviteterna avbryts eller utlöser ett undantag, slutförs den returnerade aktiviteten tidigt, i avbrutet tillstånd, och undantaget, om en inträffar, utlöses om du anropar uppgift::hämta eller task::wait för den uppgiften.

Mer information finns i aktivitetsparallellitet.

when_any

Skapar en uppgift som slutförs när någon av de uppgifter som anges som argument har slutförts.

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

Parametrar

_Iterator
Typ av iterator för indata.

_Begin
Positionen för det första elementet i elementintervallet som ska kombineras till den resulterande aktiviteten.

_End
Positionen för det första elementet utanför det område av element som ska kombineras till den resulterande aktiviteten.

_TaskOptions
_CancellationToken
Den annulleringstoken som styr annulleringen av den returnerade aktiviteten. Om du inte anger en annulleringstoken får den resulterande aktiviteten en annulleringstoken för den aktivitet som gör att den slutförs.

Returvärde

En uppgift som slutförs när någon av indatauppgifterna har slutförts. Om indatauppgifterna är av typen Tblir utdata för den här funktionen en task<std::pair<T, size_t>>>, där det första elementet i paret är resultatet av den slutförda aktiviteten och det andra elementet är indexet för den uppgift som slutfördes. Om indatauppgifterna är av typen void utdata är en task<size_t>, där resultatet är indexet för slutförandeaktiviteten.

Anmärkningar

when_any är en icke-blockerande funktion som skapar en task som resultat. Till skillnad från uppgift::väntaär det säkert att anropa den här funktionen i en UWP-app i ASTA-tråden (Application STA).

Mer information finns i aktivitetsparallellitet.

Se även

samtidighetsnamnområde

Dela via

funktioner för samtidighetsnamnområde

Alloc

Parametrar

Returvärde

Anmärkningar

asend

Parametrar

Returvärde

Anmärkningar

cancel_current_task

klar

Parametrar

create_async

Parametrar

Returvärde

Anmärkningar

CreateResourceManager

Returvärde

Anmärkningar

create_task

Parametrar

Returvärde

Anmärkningar

DisableTracing

Returvärde

EnableTracing

Returvärde

Gratis

Parametrar

Anmärkningar

get_ambient_scheduler

Returvärde

GetExecutionContextId

Returvärde

Anmärkningar

GetOSVersion

Returvärde

Anmärkningar

GetProcessorCount

Returvärde

Anmärkningar

GetProcessorNodeCount

Returvärde

Anmärkningar

GetSchedulerId

Returvärde

Anmärkningar

internal_assign_iterators

Parametrar

interruption_point

Anmärkningar

is_current_task_group_canceling

Returvärde

Anmärkningar

make_choice

Parametrar

Returvärde

make_greedy_join

Parametrar

Returvärde

make_join

Parametrar

Returvärde

make_task

Parametrar

Returvärde

Anmärkningar

parallel_buffered_sort

Parametrar

Anmärkningar

parallel_for

Parametrar

Anmärkningar

parallel_for_each

Parametrar

Anmärkningar

parallel_invoke

Parametrar

Anmärkningar