egyidejűség névtérfüggvényei

Alloc

Az egyidejű futtatókörnyezet gyorsítótárazási alwebhelyétől megadott méretű memóriablokkot foglal le.

void* __cdecl Alloc(size_t _NumBytes);

Paraméterek

_NumBytes
A lefoglalni kívánt memória bájtjainak száma.

Visszaadott érték

Mutató az újonnan lefoglalt memóriára.

Megjegyzések

További információ arról, hogy az alkalmazás mely forgatókönyvei használhatják a gyorsítótárazási alwebhelyet, lásd Feladatütemező.

asend

Aszinkron küldési művelet, amely ütemez egy feladatot az adatok célblokkba való propagálására.

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

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

Paraméterek

T
Az elküldendő adatok típusa.

_Trg
Mutató vagy hivatkozás arra a célra, amelyre az adatokat küldi.

_Adat
Hivatkozás az elküldendő adatokra.

Visszaadott érték

true, ha az üzenetet a metódus visszaadása előtt fogadták el, false ellenkező esetben.

Megjegyzések

További információ: Üzenetátadási függvények.

cancel_current_task

Megszakítja az aktuálisan végrehajtó feladatot. Ez a függvény meghívható a tevékenység törzséből a tevékenység végrehajtásának megszakításához, és a canceled állapotba való belépéséhez.

Nem támogatott forgatókönyv a függvény meghívása, ha nem egy tasktörzsében van. Ha így tesz, az nem definiált viselkedést eredményez, például összeomlást vagy nem válaszolást az alkalmazásban.

inline __declspec(noreturn) void __cdecl cancel_current_task();

átlátszó

Törli az egyidejű üzenetsort, és megsemmisíti a jelenleg lekért elemeket. Ez a módszer nem egyidejűségbiztos.

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

Paraméterek

_Fejsze

create_async

Létrehoz egy Windows Runtime aszinkron szerkezetet egy felhasználó által megadott lambda vagy függvényobjektum alapján. A create_async visszatérési típusa az egyik IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^vagy IAsyncOperationWithProgress<TResult, TProgress>^ a metódusnak átadott lambda aláírása alapján.

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

Paraméterek

_Funkció
Típus.

_Func
Az a lambda vagy függvényobjektum, amelyből Windows Runtime aszinkron szerkezetet hozhat létre.

Visszaadott érték

IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^, vagy IAsyncOperationWithProgress<TResult, TProgress>^által képviselt aszinkron szerkezet. A visszaadott felület a függvénybe átadott lambda aláírásától függ.

Megjegyzések

A lambda visszatérési típusa határozza meg, hogy a szerkezet művelet vagy művelet-e.

Az ürességet visszahozó lambdák a műveletek létrehozását okozzák. A TResult típusú eredményt visszaadó lambdák a TResult műveleteinek létrehozását okozzák.

A lambda olyan feladatot is visszaadhat task<TResult> , amely magában foglalja az aszinkron munkát, vagy egy olyan tevékenységlánc folytatása, amely az aszinkron munkát képviseli. Ebben az esetben maga a lambda lesz végrehajtva beágyazottan, mivel a feladatok azok, amelyek aszinkron módon hajtanak végre, és a lambda visszatérési típusa nincs leképezve az create_asyncáltal visszaadott aszinkron szerkezet létrehozásához. Ez azt jelenti, hogy a feladatokat<üres> visszaadó lambda műveletek létrehozását fogja eredményezni, és a feladatokat<TResult> visszaadó lambda a TResult műveleteinek létrehozását fogja okozni.

A lambda értéke lehet nulla, egy vagy két argumentum. Az érvényes argumentumok progress_reporter<TProgress> és cancellation_token, ebben a sorrendben, ha mindkettőt használják. Az argumentumok nélküli lambda aszinkron szerkezetet hoz létre anélkül, hogy képes a folyamatjelentésre. A progress_reporter<TProgress> használó lambda esetén a create_async egy aszinkron szerkezetet ad vissza, amely a progress_reporter objektum report metódusának meghívásakor a TProgress típusú előrehaladást jelenti. A cancellation_token használó lambda ezt a jogkivonatot használhatja a lemondás ellenőrzéséhez, vagy átadhatja az általa létrehozott feladatoknak, hogy az aszinkron szerkezet törlése a tevékenységek törlését okozza.

Ha a lambda vagy függvényobjektum törzse egy eredményt ad vissza (és nem egy feladat-TResult<>), a lambda aszinkron módon lesz végrehajtva a folyamat MTA-jában egy olyan feladat kontextusában, amit a futtatókörnyezet implicit módon hoz létre. A IAsyncInfo::Cancel metódus az implicit tevékenység törlését okozza.

Ha a lambda törzse egy feladatot ad vissza, a lambda beágyazott végrehajtást végez, és a lambda típus cancellation_token argumentumának deklarálásával elindíthatja a lambdán belül létrehozott tevékenységek törlését úgy, hogy átadja a jogkivonatot a létrehozásukkor. A jogkivonat register_callback metódusával is meghívhatja a futtatókörnyezetet visszahívásra, amikor meghívja IAsyncInfo::Cancel az aszinkron műveletre vagy az előállított műveletre.

Ez a függvény csak a Windows Runtime-alkalmazások számára érhető el.

CreateResourceManager

Egy olyan felületet ad vissza, amely az egyidejűségi futtatókörnyezet Resource Managerének egytonos példányát jelöli. A Resource Manager felelős azért, hogy erőforrásokat rendeljen az egymással együttműködő ütemezőkhöz.

IResourceManager* __cdecl CreateResourceManager();

Visszaadott érték

Egy IResourceManager felület.

Megjegyzések

A metódus több későbbi hívása ugyanazt a Resource Manager-példányt fogja visszaadni. A metódus minden egyes hívása növeli a Resource Manager hivatkozási számát, és az IResourceManager ::Release metódushoz kell csatlakoznia, ha az ütemező befejezte a Resource Managerrel való kommunikációt.

unsupported_os akkor történik, ha az operációs rendszert nem támogatja az egyidejűségi futtatókörnyezet.

create_task

Létrehoz egy PPL-feladat objektumot. create_task bárhol használható, ahol egy feladatkonstruktort használna. Ez elsősorban a kényelem érdekében érhető el, mivel lehetővé teszi a auto kulcsszó használatát a tevékenységek létrehozásakor.

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

Paraméterek

T
Annak a paraméternek a típusa, amelyből a feladatot létre kell venni.

_ReturnType
Típus.

_Param
Az a paraméter, amelyből a feladatot létre kell hozni. Ez lehet lambda vagy függvényobjektum, task_completion_event objektum, másik task objektum vagy Windows::Foundation::IAsyncInfo felület, ha feladatokat használ az UWP-alkalmazásban.

_TaskOptions
A tevékenység beállításai.

_Feladat
A létrehozandó feladat.

Visszaadott érték

Egy új, Ttípusú feladat, amely a _Paramszármazik.

Megjegyzések

Az első túlterhelés úgy viselkedik, mint egy feladatkonstruktor, amely egyetlen paramétert vesz igénybe.

A második túlterhelés az újonnan létrehozott tevékenységhez megadott lemondási jogkivonatot társítja. Ha ezt a túlterhelést használja, nem adhat át egy másik task objektumot első paraméterként.

A visszaadott tevékenység típusa az első paraméterből a függvényre következtet. Ha _Param egy task_completion_event<T>, egy task<T>vagy egy funktor, amely T vagy task<T>típust ad vissza, a létrehozott feladat típusa task<T>.

Ha egy UWP-alkalmazásban _Param Windows::Foundation::IAsyncOperation<T>^ vagy Windows::Foundation::IAsyncOperationWithProgress<T,P>^, vagy egy olyan funktor, amely bármelyik típust visszaadja, a létrehozott feladat task<T>típusú lesz. Ha _Param Típusa Windows::Foundation::IAsyncAction^ vagy Windows::Foundation::IAsyncActionWithProgress<P>^, vagy egy funktor, amely az ilyen típusok bármelyikét adja vissza, a létrehozott tevékenység task<void>típusú lesz.

DisableTracing

Letiltja a nyomkövetést az egyidejűségi futtatókörnyezetben. Ez a függvény elavult, mert az ETW-nyomkövetés alapértelmezés szerint nincs regisztrálva.

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

Visszaadott érték

Ha a nyomkövetés megfelelően le lett tiltva, a rendszer S_OK ad vissza. Ha a nyomkövetést korábban nem kezdeményezték, E_NOT_STARTED lesz visszaadva

EnableTracing

Engedélyezi a nyomkövetést az egyidejűségi futtatókörnyezetben. Ez a függvény elavult, mert az ETW-nyomkövetés alapértelmezés szerint be van kapcsolva.

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

Visszaadott érték

Ha a nyomkövetést helyesen kezdeményezték, S_OK ad vissza; ellenkező esetben E_NOT_STARTED lesz visszaadva.

Ingyenes

Felszabadít egy memóriablokkot, amelyet korábban a Alloc metódus lefoglalt az Egyidejű futtatókörnyezet gyorsítótárazási alwebhelyéhez.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

Paraméterek

_PAllocation
A felszabadítani kívánt Alloc metódus által korábban lefoglalt memóriára mutató mutató. Ha a _PAllocation paraméter a NULLértékre van állítva, ez a metódus figyelmen kívül hagyja, és azonnal visszatér.

Megjegyzések

További információ arról, hogy az alkalmazás mely forgatókönyvei használhatják a gyorsítótárazási alwebhelyet, lásd Feladatütemező.

get_ambient_scheduler

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

Visszaadott érték

GetExecutionContextId

A IExecutionContext felületet megvalósító végrehajtási környezethez hozzárendelhető egyedi azonosítót ad vissza.

unsigned int __cdecl GetExecutionContextId();

Visszaadott érték

Egy végrehajtási környezet egyedi azonosítója.

Megjegyzések

Ezzel a módszerrel lekérheti a végrehajtási környezet azonosítóját, mielőtt paraméterként átad egy IExecutionContext felületet a Resource Manager által kínált metódusoknak.

GetOSVersion

Az operációs rendszer verzióját adja vissza.

IResourceManager::OSVersion __cdecl GetOSVersion();

Visszaadott érték

Az operációs rendszert jelképező számbavételi érték.

Megjegyzések

unsupported_os akkor történik, ha az operációs rendszert nem támogatja az egyidejűségi futtatókörnyezet.

GetProcessorCount

A mögöttes rendszeren lévő hardverszálak számát adja vissza.

unsigned int __cdecl GetProcessorCount();

Visszaadott érték

A hardverszálak száma.

Megjegyzések

unsupported_os akkor történik, ha az operációs rendszert nem támogatja az egyidejűségi futtatókörnyezet.

GetProcessorNodeCount

A mögöttes rendszeren található NUMA-csomópontok vagy processzorcsomagok számát adja vissza.

unsigned int __cdecl GetProcessorNodeCount();

Visszaadott érték

A NUMA-csomópontok vagy processzorcsomagok száma.

Megjegyzések

Ha a rendszer több NUMA-csomópontot tartalmaz, mint a processzorcsomagokat, a rendszer visszaadja a NUMA-csomópontok számát, ellenkező esetben a processzorcsomagok száma lesz visszaadva.

unsupported_os akkor történik, ha az operációs rendszert nem támogatja az egyidejűségi futtatókörnyezet.

GetSchedulerId

A IScheduler felületet megvalósító ütemezőhöz hozzárendelhető egyedi azonosítót ad vissza.

unsigned int __cdecl GetSchedulerId();

Visszaadott érték

Egy ütemező egyedi azonosítója.

Megjegyzések

Ezzel a módszerrel beszerezheti az ütemező azonosítóját, mielőtt paraméterként átad egy IScheduler felületet a Resource Manager által kínált módszereknek.

internal_assign_iterators

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

Paraméterek

_Fejsze

_Én

első

utolsó

interruption_point

Megszakítási pontot hoz létre a lemondáshoz. Ha egy lemondás folyamatban van abban a környezetben, ahol a függvényt meghívják, ez egy belső kivételt eredményez, amely megszakítja a jelenleg futó párhuzamos munka végrehajtását. Ha a lemondás nincs folyamatban, a függvény nem tesz semmit.

inline void interruption_point();

Megjegyzések

A interruption_point() függvény által okozott belső lemondási kivételt nem szabad elkapnia. A kivételt a futtatókörnyezet fogja kifogni és kezelni, és annak elfogása a program rendellenes viselkedését okozhatja.

is_current_task_group_canceling

Annak jelzését adja vissza, hogy az aktuális környezetben jelenleg beágyazott tevékenységet végrehajtó tevékenységcsoport aktív lemondás közepén van-e (vagy hamarosan). Vegye figyelembe, hogy ha jelenleg nincs olyan tevékenységcsoport, amely az aktuális környezetben hajt végre beágyazott végrehajtást, a rendszer false ad vissza.

bool __cdecl is_current_task_group_canceling();

Visszaadott érték

true, ha az éppen futó feladatcsoport leáll, false ellenkező esetben.

Megjegyzések

További információ: Lemondási.

make_choice

Egy choice üzenetküldési blokkot hoz létre egy választható Scheduler vagy ScheduleGroup és két vagy több bemeneti forrásból.

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

Paraméterek

T1
Az első forrás üzenetblokktípusa.

T2
A második forrás üzenetblokktípusa.

_PScheduler
Az Scheduler objektum, amelyen belül a choice üzenetküldési blokk propagálási feladatának ütemezése történik.

_Item1
Az első forrás.

_Item2
A második forrás.

_Elemek
További források.

_PScheduleGroup
Az ScheduleGroup objektum, amelyen belül a choice üzenetküldési blokk propagálási feladatának ütemezése történik. A használt Scheduler objektumot az ütemezési csoport feltételezi.

Visszaadott érték

Egy choice üzenetblokk két vagy több bemeneti forrással.

make_greedy_join

Egy greedy multitype_join üzenetküldési blokkot hoz létre egy választható Scheduler vagy ScheduleGroup és két vagy több bemeneti forrásból.

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

Paraméterek

T1
Az első forrás üzenetblokktípusa.

T2
A második forrás üzenetblokktípusa.

_PScheduler
Az Scheduler objektum, amelyen belül a multitype_join üzenetküldési blokk propagálási feladatának ütemezése történik.

_Item1
Az első forrás.

_Item2
A második forrás.

_Elemek
További források.

_PScheduleGroup
Az ScheduleGroup objektum, amelyen belül a multitype_join üzenetküldési blokk propagálási feladatának ütemezése történik. A használt Scheduler objektumot az ütemezési csoport feltételezi.

Visszaadott érték

Egy greedy multitype_join üzenetblokk két vagy több bemeneti forrással.

make_join

Egy non_greedy multitype_join üzenetküldési blokkot hoz létre egy választható Scheduler vagy ScheduleGroup és két vagy több bemeneti forrásból.

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

Paraméterek

T1
Az első forrás üzenetblokktípusa.

T2
A második forrás üzenetblokktípusa.

_PScheduler
Az Scheduler objektum, amelyen belül a multitype_join üzenetküldési blokk propagálási feladatának ütemezése történik.

_Item1
Az első forrás.

_Item2
A második forrás.

_Elemek
További források.

Visszaadott érték

Egy non_greedy multitype_join üzenetblokk két vagy több bemeneti forrással.

make_task

Egy task_handle objektum létrehozására szolgáló gyári módszer.

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

Paraméterek

_Funkció
A task_handle objektum által képviselt munka végrehajtásához meghívandó függvényobjektum típusa.

_Func
A task_handle objektum által képviselt munka végrehajtásához meghívandó függvény. Ez lehet lambda funktor, egy függvény mutatója, vagy bármely objektum, amely támogatja a függvényhívási operátor egy verzióját az aláírási void operator()().

Visszaadott érték

Egy task_handle objektum.

Megjegyzések

Ez a függvény akkor hasznos, ha lambda kifejezéssel kell létrehoznia egy task_handle objektumot, mivel lehetővé teszi az objektum létrehozását anélkül, hogy ismerné a lambda funktor valódi típusát.

parallel_buffered_sort

A megadott tartomány elemeit egy nem csökkenő sorrendbe rendezi, vagy egy bináris predikátum által megadott rendezési feltételnek megfelelően, párhuzamosan. Ez a függvény szemantikailag hasonlít a std::sort, mivel összehasonlításalapú, instabil, helyben rendezés, kivéve, hogy O(n) további helyet igényel, és a rendezendő elemek alapértelmezett inicializálását igényli.

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

Paraméterek

_Random_iterator
A bemeneti tartomány iterátortípusa.

_Címfoglaló
A C++ standard kódtár-kompatibilis memóriaelosztó típusa.

_Funkció
A bináris összehasonlító típusa.

_Kezdődik
Véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány első elemének pozícióját kezeli.

_Vég
Egy véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

_Alloc
C++ standard kódtár-kompatibilis memóriaelosztó egy példánya.

_Func
Felhasználó által definiált predikátumfüggvény-objektum, amely meghatározza azt az összehasonlítási feltételt, amelyet a rendezés egymást követő elemeinek teljesítenie kell. A bináris predikátumok két argumentumot használnak, és true ad vissza, ha teljesülnek, és false, ha nem teljesülnek. Ennek az összehasonlító függvénynek szigorúan gyenge sorrendet kell szabnia a sorozat elemeinek párjaira.

_Chunk_size
Egy adattömb mimimummérete, amely két részre lesz felosztva a párhuzamos végrehajtáshoz.

Megjegyzések

Minden túlterheléshez szükség van n * sizeof(T) további helyre, ahol n a rendezendő elemek száma, T pedig az elem típusa. A legtöbb esetben parallel_buffered_sort a parallel_sortteljesítménybeli javulása jelenik meg, és parallel_sort kell használnia, ha rendelkezik a rendelkezésre álló memóriával.

Ha nem ad meg bináris összehasonlító std::less van alapértelmezettként használva, amely megköveteli, hogy az elem típusa adja meg az operátor operator<().

Ha nem ad meg kiosztótípust vagy -példányt, a rendszer a C++ standard kódtár memóriaelosztóját std::allocator<T> használja a puffer lefoglalásához.

Az algoritmus két adattömbre osztja a bemeneti tartományt, és egymás után két résztömbre osztja az egyes adattömböket a párhuzamos végrehajtáshoz. Az opcionális argumentum _Chunk_size használható annak jelzésére, hogy az algoritmusnak sorozatosan kell kezelnie a <_Chunk_size méretű adattömböket.

parallel_for

parallel_for az indexek tartományán halad át, és egy felhasználó által megadott függvényt hajt végre az egyes iterációkban, párhuzamosan.

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

Paraméterek

_Index_type
Az iterációhoz használt index típusa.

_Funkció
Az egyes iterációkban végrehajtandó függvény típusa.

_Particionáló
A megadott tartomány particionálásához használt particionáló típusa.

első
Az iteráció első indexe.

utolsó
Az az index, amely az utolsó indexen múlt, amelyet az iteráció tartalmaz.

_Lépés
Az az érték, amellyel first és lastközötti iterálás során lépkedhet. A lépésnek pozitívnak kell lennie. invalid_argument akkor lesz eldobva, ha a lépés 1-nél kisebb.

_Func
Az egyes iterációkban végrehajtandó függvény. Ez lehet lambda kifejezés, függvénymutató vagy bármely objektum, amely támogatja a függvényhívási operátor egy verzióját az aláírási void operator()(_Index_type).

_Rész
A particionáló objektumra mutató hivatkozás. Az argumentum lehet az egyik constauto_partitioner&, conststatic_partitioner&, constsimple_partitioner& vagy affinity_partitioner& Ha affinity_partitioner objektumot használ, a hivatkozásnak nem konstans l-érték referenciának kell lennie, hogy az algoritmus tárolhassa az állapotot a jövőbeli ciklusok újbóli használatához.

Megjegyzések

További információ: Párhuzamos algoritmusok.

parallel_for_each

parallel_for_each egy megadott függvényt alkalmaz egy tartomány minden elemére, párhuzamosan. Szemantikailag megegyezik a for_each névtér std függvényével, azzal a különbségekkel, hogy az elemek iterációja párhuzamosan történik, és az iteráció sorrendje meghatározatlan. Az _Func argumentumnak támogatnia kell az űrlap függvényhívási operátorát, operator()(T) ahol a T paraméter az iterált tároló elemtípusa.

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

Paraméterek

_Iterator
A tárolón keresztüli iteráláshoz használt iterátor típusa.

_Funkció
A tartomány egyes elemeire alkalmazott függvény típusa.

_Particionáló
első
Egy iterátor, amely a párhuzamos iteráció első elemének pozícióját kezeli.

utolsó
Egy iterátor, amely a párhuzamos iteráció utolsó eleméhez tartozó pozíciót kezeli.

_Func
A tartomány egyes elemeire alkalmazott, felhasználó által definiált függvényobjektum.

Megjegyzések

auto_partitioner explicit particionáló nélkül használjuk a túlterheléshez.

A véletlenszerű hozzáférést nem támogató iterátorok esetében csak auto_partitioner támogatott.

További információ: Párhuzamos algoritmusok.

parallel_invoke

Párhuzamosan hajtja végre a paraméterekként megadott függvényobjektumokat, és letiltja a végrehajtás befejezését. Minden függvényobjektum lehet lambda kifejezés, egy függvénymutató vagy bármely olyan objektum, amely támogatja a függvényhívási operátort az aláírási 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);

Paraméterek

_Function1
Az első párhuzamosan végrehajtandó függvényobjektum típusa.

_Function2
A párhuzamosan végrehajtandó második függvényobjektum típusa.

_Function3
A párhuzamosan végrehajtandó harmadik függvényobjektum típusa.

_Function4
A párhuzamosan végrehajtandó negyedik függvényobjektum típusa.

_Function5
A párhuzamosan végrehajtandó ötödik függvényobjektum típusa.

_Function6
A párhuzamosan végrehajtandó hatodik függvényobjektum típusa.

_Function7
A párhuzamosan végrehajtandó hetedik függvényobjektum típusa.

_Function8
A párhuzamosan végrehajtandó nyolcadik függvényobjektum típusa.

_Function9
A párhuzamosan végrehajtandó kilencedik függvényobjektum típusa.

_Function10
A párhuzamosan végrehajtandó tizedik függvényobjektum típusa.

_Func1
Az első párhuzamosan végrehajtandó függvényobjektum.

_Func2
A második, párhuzamosan végrehajtandó függvényobjektum.

_Func3
A harmadik, párhuzamosan végrehajtandó függvényobjektum.

_Func4
A párhuzamosan végrehajtandó negyedik függvényobjektum.

_Func5
A párhuzamosan végrehajtandó ötödik függvényobjektum.

_Func6
A hatodik, párhuzamosan végrehajtandó függvényobjektum.

_Func7
A hetedik, párhuzamosan végrehajtandó függvényobjektum.

_Func8
A párhuzamosan végrehajtandó nyolcadik függvényobjektum.

_Func9
A párhuzamosan végrehajtandó kilencedik függvényobjektum.

_Func10
A párhuzamosan végrehajtandó tizedik függvényobjektum.

Megjegyzések

Vegye figyelembe, hogy a paraméterekként megadott függvényobjektumok közül egy vagy több inline módon is végrehajtható a hívókörnyezetben.

Ha a függvény paraméterként átadott egy vagy több függvényobjektum kivételt jelez, a futtatókörnyezet kiválaszt egy ilyen kivételt, és propagálja azt a parallel_invokehívásából.

További információ: Párhuzamos algoritmusok.

parallel_radixsort

Egy adott tartomány elemeit nem csökkenő sorrendbe rendezi radix rendezési algoritmus használatával. Ez egy stabil rendezési függvény, amely olyan kivetítési függvényt igényel, amely a projektelemeket aláíratlan egész számszerű kulcsokká rendezheti. A rendezés alatt álló elemekhez alapértelmezett inicializálás szükséges.

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

Paraméterek

_Random_iterator
A bemeneti tartomány iterátortípusa.

_Címfoglaló
A C++ standard kódtár-kompatibilis memóriaelosztó típusa.

_Funkció
A vetítési függvény típusa.

_Kezdődik
Véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány első elemének pozícióját kezeli.

_Vég
Egy véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

_Alloc
C++ standard kódtár-kompatibilis memóriaelosztó egy példánya.

_Proj_func
Felhasználó által definiált kivetítőfüggvény-objektum, amely egy elemet integrál értékké alakít át.

_Chunk_size
Egy adattömb mimimummérete, amely két részre lesz felosztva a párhuzamos végrehajtáshoz.

Megjegyzések

Minden túlterheléshez szükség van n * sizeof(T) további helyre, ahol n a rendezendő elemek száma, T pedig az elem típusa. Az aláírási I _Proj_func(T) rendelkező unary projection funktornak kulcs visszaadásához kell megadnia egy elemet, ahol T az elem típusa, I pedig egy aláíratlan egész szám típusú.

Ha nem ad meg vetítési függvényt, a rendszer egy alapértelmezett vetítési függvényt használ, amely egyszerűen visszaadja az elemet az integráltípusokhoz. A függvény fordítása sikertelen lesz, ha az elem nem integrál típusú vetítési függvény hiányában.

Ha nem ad meg kiosztótípust vagy -példányt, a rendszer a C++ standard kódtár memóriaelosztóját std::allocator<T> használja a puffer lefoglalásához.

parallel_reduce

Kiszámítja egy adott tartomány összes elemének összegét az egymást követő részleges összegek számításával, vagy az egymást követő részleges eredmények eredményét, hasonlóan az összegtől eltérő megadott bináris művelettel párhuzamosan. parallel_reduce szemantikailag hasonlít a std::accumulate, azzal a kivételrel, hogy a bináris műveletnek asszociatívnak kell lennie, és a kezdeti érték helyett identitásértéket igényel.

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

Paraméterek

_Forward_iterator
A bemeneti tartomány iterátortípusa.

_Sym_reduce_fun
A szimmetrikus redukciós függvény típusa. Ennek aláírási _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type)rendelkező függvénytípusnak kell lennie, ahol a _Reduce_type megegyezik az identitástípussal és a csökkentés eredménytípusával. A harmadik túlterhelés esetén ennek konzisztensnek kell lennie a _Range_reduce_funkimeneti típusával.

_Reduce_type
Az a típus, amelyre a bemenet csökken, amely eltérhet a bemeneti elem típusától. A visszatérési érték és az identitás értéke ilyen típusú lesz.

_Range_reduce_fun
A tartománycsökkentési függvény típusa. Ennek aláírási _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type)rendelkező függvénytípusnak kell lennie, _Reduce_type megegyezik az identitástípussal és a csökkentés eredménytípusával.

_Kezdődik
Egy bemeneti iterátor, amely a csökkenteni kívánt tartomány első elemét kezeli.

_Vég
Egy bemeneti iterátor, amely a csökkenteni kívánt tartomány utolsó elemétől egy pozícióban lévő elemet kezeli.

_Azonosság
Az identitásérték _Identity azonos típusú, mint a csökkentés eredménytípusa, valamint az iterátor value_type az első és a második túlterhelés esetén. A harmadik túlterhelés esetén az identitásértéknek ugyanolyan típusúnak kell lennie, mint a csökkentés eredménytípusa, de eltérhet az iterátor value_type. Megfelelő értékkel kell rendelkeznie, hogy a tartománycsökkentési operátor _Range_funa value_type és az identitásérték egyetlen elemének tartományára alkalmazva úgy viselkedjen, mint az érték típusának a value_type típusától az identitástípusig.

_Sym_fun
A csökkentés második során használt szimmetrikus függvény. További információért tekintse meg a Megjegyzések című témakört.

_Range_fun
A csökkentés első fázisában használt függvény. További információért tekintse meg a Megjegyzések című témakört.

Visszaadott érték

A csökkentés eredménye.

Megjegyzések

Párhuzamos csökkentés végrehajtásához a függvény a tartományt adattömbökre osztja az alapul szolgáló ütemező számára elérhető feldolgozók száma alapján. A csökkentés két fázisban történik, az első fázis az egyes adattömbökön belül végez csökkentést, a második fázis pedig az egyes adattömbök részleges eredményei közötti csökkentést.

Az első túlterheléshez az iterátor value_type, Tazonosnak kell lennie az identitásérték típusával és a csökkentési eredmény típusával. A T elemtípusnak biztosítania kell az operátornak T T::operator + (T) az egyes adattömbek elemeinek csökkentéséhez. Ugyanez az operátor a második fázisban is használatos.

A második túlterheléshez az is szükséges, hogy az iterátor value_type azonos legyen az identitásérték típusával és a csökkentési eredmény típusával. A megadott bináris operátor _Sym_fun mindkét csökkentési fázisban használatos, az identitás értéke pedig az első fázis kezdeti értéke.

A harmadik túlterhelés esetén az identitásérték típusának meg kell egyeznie a csökkentési eredmény típusával, de az iterátor value_type eltérhetnek a kettőtől. A tartománycsökkentési függvény _Range_fun az első fázisban az identitásértéket használja kezdeti értékként, a bináris függvény _Sym_reduce_fun pedig a második fázisban lévő aleredményekre lesz alkalmazva.

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

Paraméterek

_Random_iterator
A bemeneti tartomány iterátortípusa.

_Funkció
A bináris összehasonlító funktor típusa.

_Kezdődik
Véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány első elemének pozícióját kezeli.

_Vég
Egy véletlenszerű hozzáférésű iterátor, amely a rendezendő tartomány utolsó elemétől egynél korábbi pozícióval foglalkozik.

_Chunk_size
A párhuzamos végrehajtáshoz két részre felosztott adattömb minimális mérete.

Megjegyzések

Az első túlterhelés a bináris összehasonlító std::lesshasznál.

A második túlterhelt a megadott bináris összehasonlítót használja, amelynek aláírási bool _Func(T, T) kell lennie, ahol T a bemeneti tartomány elemeinek típusa.

parallel_transform

Egy megadott függvényobjektumot alkalmaz egy forrástartomány minden elemére vagy két forrástartomány elemeinek párjára, és a függvényobjektum visszatérési értékeit egy céltartományba másolja párhuzamosan. Ez a funkció szemantikailag egyenértékű a 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);

Paraméterek

_Input_iterator1
Az első vagy csak bemeneti iterátor típusa.

_Output_iterator
A kimeneti iterátor típusa.

_Unary_operator
A bemeneti tartomány egyes elemein végrehajtandó unary funktor típusa.

_Input_iterator2
A második bemeneti iterátor típusa.

_Binary_operator
A bináris funktor típusa a két forrástartomány elemein párban végrehajtva.

_Particionáló
első1
Egy bemeneti iterátor, amely az első vagy egyetlen működtetni kívánt forrástartomány első elemének pozícióját kezeli.

utolsó1
Egy bemeneti iterátor, amely az első vagy egyetlen működtetni kívánt forrástartomány utolsó elemén egynél korábbi pozíciót kezel.

_Eredmény
Egy kimeneti iterátor, amely a céltartomány első elemének pozícióját kezeli.

_Unary_op
A forrástartomány egyes elemeire alkalmazott, felhasználó által definiált nem függvényobjektum.

első2
Egy bemeneti iterátor, amely a második forrástartomány első elemének pozícióját kezeli.

_Binary_op
Egy felhasználó által definiált bináris függvényobjektum, amelyet a rendszer a két forrástartományra párban, előrefelé alkalmaz.

Visszaadott érték

Egy kimeneti iterátor, amely a céltartomány utolsó elemétől egy korábbi pozíciót kezeli, amely a függvényobjektum által átalakított kimeneti elemeket fogadja.

Megjegyzések

auto_partitioner explicit particionáló argumentum nélkül használható a túlterhelésekhez.

A véletlenszerű hozzáférést nem támogató iterátorok esetében csak auto_partitioner támogatott.

Az argumentumot használó túlterhelések _Unary_op átalakítják a bemeneti tartományt a kimeneti tartományba azáltal, hogy a bemeneti tartomány minden elemére alkalmazza a nem naplózatlan tölcsért. _Unary_op támogatnia kell a függvényhívási operátort aláírási operator()(T), ahol T az iterált tartomány értéktípusa.

Az argumentumot használó túlterhelések _Binary_op átalakítanak két bemeneti tartományt a kimeneti tartományba úgy, hogy a bináris funktort az első bemeneti tartomány egyik elemére, a második bemeneti tartomány egyik elemére alkalmazza. _Binary_op támogatnia kell a függvényhívási operátort aláírási operator()(T, U), ahol T, U a két bemeneti iterátor értéktípusai.

További információ: Párhuzamos algoritmusok.

kap

Általános fogadási implementáció, amely lehetővé teszi, hogy a környezet pontosan egy forrásból várja meg az adatokat, és szűrje az elfogadott értékeket.

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

Paraméterek

T
A hasznos adat típusa.

_Src
Mutató vagy hivatkozás arra a forrásra, amelytől az adatok várhatók.

_Időkorlát
Az a maximális idő, amelyre a metódusnak az adatok esetében ezredmásodpercben meg kell lennie.

_Filter_proc
Szűrőfüggvény, amely meghatározza, hogy az üzeneteket el kell-e fogadni.

Visszaadott érték

A forrásból származó, hasznos adattípusú érték.

Megjegyzések

Ha a _Timeout paraméter értéke nem az állandó COOPERATIVE_TIMEOUT_INFINITE, akkor a rendszer kivételt operation_timed_out, ha a megadott idő lejár az üzenet fogadása előtt. Ha nulla hosszúságú időtúllépést szeretne, a try_receive függvényt kell használnia, nem pedig receive (nulla) időtúllépéssel meghívni 0, mivel hatékonyabb, és nem ad kivételeket az időtúllépésekre.

További információ: Üzenetátadási függvények.

run_with_cancellation_token

Egy függvényobjektumot azonnal és szinkron módon hajt végre egy adott lemondási jogkivonat kontextusában.

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

Paraméterek

_Funkció
A meghívandó függvényobjektum típusa.

_Func
A végrehajtandó függvényobjektum. Ennek az objektumnak támogatnia kell a függvényhívási operátort a void(void) aláírással.

_Ct
A függvényobjektum implicit törlését vezérlő lemondási jogkivonat. Használja a cancellation_token::none(), ha úgy szeretné végrehajtani a függvényt, hogy a szülő tevékenységcsoport implicit lemondása nem lehetséges.

Megjegyzések

A függvényobjektum megszakítási pontjai a cancellation_token megszakításakor aktiválódnak. A explicit jogkivonat _Ct elkülöníti ezt a _Func a szülő lemondásától, ha a szülő más jogkivonattal rendelkezik, vagy nincs jogkivonata.

küld

Szinkron küldési művelet, amely megvárja, amíg a cél elfogadja vagy elutasítja az üzenetet.

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

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

Paraméterek

T
A hasznos adat típusa.

_Trg
Mutató vagy hivatkozás arra a célra, amelyre az adatokat küldi.

_Adat
Hivatkozás az elküldendő adatokra.

Visszaadott érték

true, ha az üzenetet elfogadták, false ellenkező esetben.

Megjegyzések

További információ: Üzenetátadási függvények.

set_ambient_scheduler

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

Paraméterek

_Táblázat
A beállítani kívánt környezeti ütemező.

set_task_execution_resources

Az egyidejűségi futtatókörnyezet belső feldolgozói szálai által használt végrehajtási erőforrásokat a megadott affinitási csoportra korlátozza.

Ezt a metódust csak a Resource Manager létrehozása előtt vagy két Resource Manager-élettartam között lehet meghívni. Többször is meghívható, ha a Resource Manager nem létezik a meghívás időpontjában. Az affinitási korlát beállítása után a set_task_execution_resources metódus következő érvényes hívásáig érvényben marad.

A megadott affinitási maszknak nem kell a folyamat affinitási maszkjának egy részhalmazának lennie. A folyamat affinitása szükség esetén frissül.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

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

Paraméterek

_ProcessAffinityMask
Az affinitási maszk, amelybe az egyidejűségi futtatókörnyezeti feldolgozói szálakat korlátozni kell. Ezt a módszert csak akkor használja 64-nél több hardverszállal rendelkező rendszeren, ha az egyidejűségi futtatókörnyezetet az aktuális processzorcsoport egy részhalmazára szeretné korlátozni. Általában annak a metódusnak a verzióját kell használnia, amely paraméterként fogadja el a csoport affinitásainak tömbét, hogy korlátozza a 64-nél több hardverszállal rendelkező gépek affinitását.

darabszám
A GROUP_AFFINITYparaméter által megadott tömb _PGroupAffinity bejegyzéseinek száma.

_PGroupAffinity
GROUP_AFFINITY bejegyzések tömbje.

Megjegyzések

A metódus invalid_operation kivételt fog eredményezni, ha egy Resource Manager jelen van a meghíváskor, és invalid_argument kivételt, ha az affinitás megadott erőforráskészletet eredményez.

A paraméterként a csoport affinitásainak tömbjeként használt metódus verziója csak Windows 7-es vagy újabb verziójú operációs rendszereken használható. Ellenkező esetben a rendszer kivételt invalid_operation.

Ha programozott módon módosítja a folyamat affinitását a metódus meghívása után, akkor a Resource Manager nem fogja újra kiértékelni azt az affinitást, amelyre korlátozva van. Ezért a metódus meghívása előtt minden módosítást végre kell hozni a folyamat affinitásán.

cserél

Két concurrent_vector objektum elemeinek cseréje.

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

Paraméterek

T
Az egyidejű vektorokban tárolt elemek adattípusa.

_Fejsze
Az egyidejű vektorok kiosztó típusa.

_Egy
Az egyidejű vektor, amelynek elemeit az egyidejű vektor _Belemeivel kell kicserélni.

_B
Az egyidejű vektor, amely biztosítja a felcserélni kívánt elemeket, vagy az a vektor, amelynek elemeit az egyidejű vektor _Aelemeivel kell kicserélni.

Megjegyzések

A sablonfüggvény egy olyan algoritmus, amely a tárolóosztályra concurrent_vector a tagfüggvény _Avégrehajtásához. concurrent_vector::swap(_B). Ezek a függvénysablonok fordító általi részleges sorrendjének példányai. Ha a sablonfüggvények túlterheltek oly módon, hogy a sablon és a függvényhívás egyezése nem egyedi, akkor a fordító kiválasztja a sablonfüggvény leg specializáltabb verzióját. A template <class T> void swap(T&, T&)sablonfüggvény általános verziója hozzárendelés szerint működik, és lassú művelet. Az egyes tárolók speciális verziója sokkal gyorsabb, mivel a tárolóosztály belső ábrázolása is használható.

Ez a módszer nem egyidejűségbiztos. Ha ezt a metódust meghívja, győződjön meg arról, hogy más szálak nem hajtanak végre műveleteket az egyidejű vektorok egyikén sem.

task_from_exception

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

Paraméterek

_TaskType

_ExType

_Kivétel

_TaskOptions

Visszaadott érték

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

Paraméterek

_Param

_TaskOptions

Visszaadott érték

Trace_agents_register_name

A megadott nevet társítja az üzenetblokkhoz vagy -ügynökhöz az ETW-nyomkövetésben.

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

Paraméterek

T
Az objektum típusa. Ez általában üzenetblokk vagy ügynök.

_PObject
A nyomkövetésben elnevezett üzenetblokkra vagy ügynökre mutató mutató.

_Név
Az adott objektum neve.

try_receive

Általános kipróbálási implementáció, amely lehetővé teszi, hogy a környezet pontosan egy forrásból keressen adatokat, és szűrje az elfogadott értékeket. Ha az adatok nem állnak készen, a metódus falsead vissza.

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

Paraméterek

T
A hasznos adat típusa

_Src
Mutató vagy hivatkozás arra a forrásra, amelytől az adatok várhatók.

_érték
Hivatkozás arra a helyre, ahol az eredmény el lesz helyezve.

_Filter_proc
Szűrőfüggvény, amely meghatározza, hogy az üzeneteket el kell-e fogadni.

Visszaadott érték

Egy bool érték, amely azt jelzi, hogy egy hasznos adat _valuelett-e elhelyezve.

Megjegyzések

További információ: Üzenetátadási függvények.

várj

Egy adott ideig szünetelteti az aktuális környezetet.

void __cdecl wait(unsigned int _Milliseconds);

Paraméterek

_Ezredmásodperc
Az aktuális környezethez tartozó ezredmásodpercek számát fel kell függeszteni. Ha a _Milliseconds paraméter a 0értékre van állítva, a folytatás előtt az aktuális környezetnek végrehajtást kell eredményeznie más futtatható környezetekben.

Megjegyzések

Ha ezt a metódust concurrency runtime scheduler-környezetben hívják meg, az ütemező egy másik környezetet fog találni a mögöttes erőforráson való futtatáshoz. Mivel az ütemező együttműködő jellegű, ez a környezet nem folytatható pontosan a megadott ezredmásodperc után. Ha az ütemező más, az ütemezőnek nem együttműködő feladatok végrehajtásával van elfoglalva, a várakozási idő határozatlan lehet.

when_all

Létrehoz egy feladatot, amely sikeresen befejeződik, ha az argumentumként megadott összes tevékenység sikeresen befejeződött.

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

Paraméterek

_Iterator
A bemeneti iterátor típusa.

_Kezdődik
Az eredményül kapott tevékenységhez egyesítendő elemek tartományának első elemének pozíciója.

_Vég
Az első elem pozíciója az eredményül kapott tevékenységhez kombinálandó elemek tartományán túl.

_TaskOptions
A task_options objektum.

Visszaadott érték

Olyan feladat, amely sikeresen befejeződött, amikor az összes bemeneti tevékenység sikeresen befejeződött. Ha a bemeneti tevékenységek Ttípusúak, a függvény kimenete egy task<std::vector<T>>lesz. Ha a bemeneti tevékenységek típusa void a kimeneti tevékenység is task<void>lesz.

Megjegyzések

when_all egy nem blokkoló függvény, amely ennek eredményeként task hoz létre. Ellentétben feladat::wait, nyugodtan meghívhatja ezt a függvényt egy UWP-alkalmazásban az ASTA (Application STA) szálon.

Ha az egyik tevékenységet megszakítják, vagy kivételt vetnek ki, a visszaadott tevékenység korán, megszakított állapotban fejeződik be, és a kivétel , ha előfordul, akkor a rendszer a következőt fogja dobni, ha meghívja tevékenységet:: vagy task::wait lekérése az adott tevékenységre.

További információ: Feladat-párhuzamosság.

when_any

Létrehoz egy feladatot, amely sikeresen befejeződik, ha az argumentumként megadott tevékenységek bármelyike sikeresen befejeződik.

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

Paraméterek

_Iterator
A bemeneti iterátor típusa.

_Kezdődik
Az eredményül kapott tevékenységhez egyesítendő elemek tartományának első elemének pozíciója.

_Vég
Az első elem pozíciója az eredményül kapott tevékenységhez kombinálandó elemek tartományán túl.

_TaskOptions
_CancellationToken
A visszaadott feladat törlését vezérlő lemondási jogkivonat. Ha nem ad meg lemondási jogkivonatot, az eredményül kapott tevékenység megkapja annak a tevékenységnek a lemondási jogkivonatát, amely miatt a művelet befejeződik.

Visszaadott érték

Olyan feladat, amely sikeresen befejeződik, ha a bemeneti tevékenységek bármelyike sikeresen befejeződött. Ha a bemeneti tevékenységek Ttípusúak, a függvény kimenete egy task<std::pair<T, size_t>>>lesz, ahol a pár első eleme a befejező tevékenység eredménye, a második elem pedig a befejezett tevékenység indexe. Ha a bemeneti tevékenységek típusa void a kimenet egy task<size_t>, ahol az eredmény a befejező tevékenység indexe.

Megjegyzések

when_any egy nem blokkoló függvény, amely ennek eredményeként task hoz létre. Ellentétben feladat::wait, nyugodtan meghívhatja ezt a függvényt egy UWP-alkalmazásban az ASTA (Application STA) szálon.

További információ: Feladat-párhuzamosság.

Lásd még:

egyidejű névtér

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-11-07

Megosztás a következőn keresztül:

egyidejűség névtérfüggvényei

Alloc

Paraméterek

Visszaadott érték

Megjegyzések

asend

Paraméterek

Visszaadott érték

Megjegyzések

cancel_current_task

átlátszó

Paraméterek

create_async

Paraméterek

Visszaadott érték

Megjegyzések

CreateResourceManager

Visszaadott érték

Megjegyzések

create_task

Paraméterek

Visszaadott érték

Megjegyzések

DisableTracing

Visszaadott érték

EnableTracing

Visszaadott érték

Ingyenes

Paraméterek

Megjegyzések

get_ambient_scheduler

Visszaadott érték

GetExecutionContextId

Visszaadott érték

Megjegyzések

GetOSVersion

Visszaadott érték

Megjegyzések

GetProcessorCount

Visszaadott érték

Megjegyzések

GetProcessorNodeCount

Visszaadott érték

Megjegyzések

GetSchedulerId

Visszaadott érték

Megjegyzések

internal_assign_iterators

Paraméterek

interruption_point

Megjegyzések

is_current_task_group_canceling

Visszaadott érték

Megjegyzések

make_choice

Paraméterek

Visszaadott érték

make_greedy_join

Paraméterek

Visszaadott érték

make_join

Paraméterek

Visszaadott érték

make_task

Paraméterek

Visszaadott érték

Megjegyzések

parallel_buffered_sort

Paraméterek

Megjegyzések

parallel_for

Paraméterek

Megjegyzések

parallel_for_each

Paraméterek

Megjegyzések

parallel_invoke

Paraméterek

Megjegyzések