concurrency-Namespace

Der Concurrency-Namespace stellt Klassen und Funktionen bereit, die Ihnen den Zugriff auf die Concurrency Runtime ermöglichen, ein Framework zur parallelen Programmierung für C++. Weitere Informationen finden Sie unter Concurrency Runtime.

Syntax

namespace concurrency;

Mitglieder

TypeDefs

Name	Beschreibung
`runtime_object_identity`	Jede Nachrichteninstanz verfügt über eine Identität, die ihr beim Klonen folgt und zwischen den Messaging-Komponenten weitergegeben wird. Dies kann nicht die Adresse des Meldungsobjekts sein.
`task_status`	Ein Typ, der den abschließenden Zustand einer Aufgabe darstellt. Gültige Werte sind `completed` und `canceled`.
`TaskProc`	Eine elementare Abstraktion für eine Aufgabe, die definiert ist als `void (__cdecl * TaskProc)(void *)`. Ein `TaskProc` wird aufgerufen, um den Hauptteil einer Aufgabe auszuführen.
`TaskProc_t`	Eine elementare Abstraktion für eine Aufgabe, die definiert ist als `void (__cdecl * TaskProc_t)(void *)`. Ein `TaskProc` wird aufgerufen, um den Text einer Aufgabe aufzurufen.

Klassen

Name	Beschreibung
affinity_partitioner-Klasse	Die `affinity_partitioner`-Klasse ist der `static_partitioner`-Klasse ähnlich, allerdings wird die Cacheaffinität dank der Auswahl, den Arbeitsthreads Unterbereiche zuzuordnen, verbessert. Es kann die Leistung erheblich verbessern, wenn eine Schleife über das gleiche Dataset erneut ausgeführt wird und die Daten in den Cache passen. Beachten Sie, dass dasselbe `affinity_partitioner`-Objekt mit nachfolgenden Iterationen einer parallelen Schleife verwendet werden muss, die für einen bestimmten Datensatz ausgeführt wird, um von der Datenlokalität zu profitieren.
agent-Klasse	Diese Klasse ist als Basisklasse für alle unabhängigen Agents vorgesehen. Sie wird verwendet, um den Zustand von anderen Agents auszublenden und mithilfe von Meldungsübergabe zu interagieren.
auto_partitioner-Klasse	Die `auto_partitioner`-Klasse repräsentiert die Standardmethode `parallel_for`, `parallel_for_each` und `parallel_transform`, die verwendet wird, um den Bereich zu partitionieren, über den sie iterieren. Bei dieser Partitionierungsmethode wird Bereichsraub für den Lastenausgleich sowie der Iteration-Abbruch verwendet.
bad_target-Klasse	Diese Klasse beschreibt eine Ausnahme, die dann ausgelöst wird, wenn einem Meldungsblock ein Zeiger auf ein Ziel zugeordnet wird, das für die auszuführende Operation ungültig ist.
call-Klasse	Ein `call`-Meldungsblock ist ein geordneter `target_block` mit mehreren Quellen, der eine bestimmte Funktion aufruft, wenn eine Nachricht empfangen wird.
cancellation_token-Klasse	Mit der `cancellation_token`-Klasse kann bestimmt werden, ob für einen Vorgang ein Abbruch angefordert wurde. Ein gegebenes Token kann mit `task_group`, `structured_task_group` oder `task` für einen impliziten Abbruch verbunden werden. Es kann auch auf eine Stornierung abgefragt oder ein Rückruf registriert werden, wenn und falls das zugeordnete `cancellation_token_source`-Element storniert wird.
"CancellationTokenRegistration-Klasse"	Die `cancellation_token_registration`-Klasse stellt eine Rückrufbenachrichtigung von `cancellation_token` dar. Bei Verwendung der `register`-Methode auf einem `cancellation_token` zum Empfangen von Benachrichtigungen darüber, wann ein Abbruch auftritt, wird ein `cancellation_token_registration`-Objekt als Handle für den Rückruf zurückgegeben. So kann der Aufrufer mit der `deregister`-Methode anfordern, dass ein bestimmter Rückruf nicht mehr ausgeführt wird.
cancellation_token_source-Klasse	Mit der `cancellation_token_source`-Klasse wird die Fähigkeit repräsentiert, einen abbrechbaren Vorgang abzubrechen.
choice-Klasse	Ein `choice`-Meldungsblock ist ein Block mit mehreren Quellen und einem einzelnen Ziel, der eine Kontrollflussinteraktion zwischen mehreren Quellen darstellt. Der Auswahlblock wartet, bis eine von mehreren Quellen eine Meldung erzeugt, und gibt den Index der Quelle, von der die Meldung erzeugt wurde, weiter.
Kombinierbare Klasse	Das `combinable<T>`-Objekt ist dazu gedacht, threadprivate Kopien von Daten bereitzustellen, mit denen sperrenfreie, threadlokale Unterberechnungen in parallelen Algorithmen durchgeführt werden können. Am Ende der parallelen Ausführung können die thread-privaten Unterberechnungen in einem Gesamtergebnis zusammengeführt werden. Diese Klasse kann anstelle einer freigegebenen Variable verwendet werden, und sie kann zu einer Leistungsverbesserung führen, wenn andernfalls Konflikte mit dieser freigegebenen Variable entstehen würden.
Concurrent-Priority-Queue-Klasse	Die `concurrent_priority_queue`-Klasse ist ein Container, der es mehreren Threads gleichzeitig ermöglicht, für Elemente die Vorgänge "push" und "pop" auszuführen. Elemente werden in der Reihenfolge ihrer Priorität entnommen, wobei die Priorität durch einen als Vorlagenargument angegebenen Funktor bestimmt wird.
ConcurrentQueue-Klasse	Die `concurrent_queue`-Klasse ist eine Sequenzcontainerklasse, die "First In, First Out"-Zugriff auf ihre Elemente zulässt. Sie aktiviert einen beschränkten Satz von parallelitätssicheren Vorgängen, z. B. `push` und `try_pop`.
concurrent_unordered_map-Klasse	Die `concurrent_unordered_map`- Klasse ist ein parallelitätssicherer Container, mit dem eine Folge von Elementen variierender Länge des Typs `std::pair<const K, _Element_type>` gesteuert wird. Die Sequenz wird so dargestellt, dass parallelitätssichere Vorgänge für Anfügen, Elementzugriff, Iteratorzugriff und Iteratordurchläufe ermöglicht werden.
Die concurrent_unordered_multimap-Klasse	Die `concurrent_unordered_multimap`- Klasse ist ein parallelitätssicherer Container, mit dem eine Folge von Elementen variierender Länge des Typs `std::pair<const K, _Element_type>` steuert. Die Sequenz wird so dargestellt, dass parallelitätssichere Vorgänge für Anfügen, Elementzugriff, Iteratorzugriff und Iteratordurchläufe ermöglicht werden.
concurrent_unordered_multiset-Klasse	Die `concurrent_unordered_multiset` Klasse ist ein Parallelitätssicherer Container, der eine unterschiedliche Abfolge von Elementen vom Typ K steuert. Die Sequenz wird auf eine Weise dargestellt, die Parallelitätssicheren Anfüge-, Elementzugriff, Iteratorzugriff und Iterator-Traversalvorgänge ermöglicht.
concurrent_unordered_set-Klasse	Die `concurrent_unordered_set` Klasse ist ein Parallelitätssicherer Container, der eine unterschiedliche Abfolge von Elementen vom Typ K steuert. Die Sequenz wird auf eine Weise dargestellt, die Parallelitätssicheren Anfüge-, Elementzugriff, Iteratorzugriff und Iterator-Traversalvorgänge ermöglicht.
concurrent_vector-Klasse	Die `concurrent_vector`-Klasse ist eine Sequenzcontainerklasse, die zufälligen Zugriff auf jedes Element zulässt. Sie aktiviert parallelitätssichere Operationen für Anfügen, Elementzugriff, Iteratorzugriff und Iteratordurchlauf.
context-Klasse	Stellt eine Abstraktion für einen Ausführungskontext dar.
context_self_unblock-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn die `Unblock`-Methode für ein `Context`-Objekt aufgerufen wird, das im gleichen Kontext aufgerufen wird. Das würde den Versuch eines bestimmten Kontexts, sich selbst zu entsperren, anzeigen.
Context_Unblock_Unbalanced-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn Aufrufe der `Block`-Methode und der `Unblock`-Methode eines `Context`-Objekts nicht ordnungsgemäß zugeordnet werden.
critical_section-Klasse	Ein nicht wieder eintretender Mutex, der explizit die Concurrency Runtime beachtet.
CurrentScheduler-Klasse	Stellt eine Abstraktion für den aktuellen Planer dar, der dem aufrufenden Kontext zugeordnet ist.
default_scheduler_exists-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, sobald die `Scheduler::SetDefaultSchedulerPolicy`-Methode aufgerufen wird, sofern ein Standardplaner bereits innerhalb des Prozesses vorhanden ist.
Event-Klasse	Ein Ereignis für manuelles Zurücksetzen, das explizit die Concurrency Runtime beachtet.
Improper_Lock-Klasse	Diese Klasse beschreibt eine Ausnahme, die auftritt, wenn eine Sperre nicht ordnungsgemäß erworben wird.
ImproperSchedulerAttach-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn die `Attach`-Methode für ein `Scheduler`-Objekt aufgerufen wird, das bereits an den aktuellen Kontext angefügt wurde.
improper_scheduler_detach Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn die `CurrentScheduler::Detach`-Methode für einen Kontext aufgerufen wird, der nicht mittels der `Attach`-Methode eines `Scheduler`-Objekts an einen Scheduler angeschlossen wurde.
improper_scheduler_reference-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn die `Reference`-Methode für ein `Scheduler`-Objekt aufgerufen wird, das sich im Prozess des Herunterfahrens befindet, von einem Kontext, der nicht Teil dieses Planers ist.
invalid_link_target-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn die `link_target`-Methode eines Meldungsblocks aufgerufen wird und der Meldungsblock keine Verknüpfung mit dem Ziel erstellen kann. Dies kann das Ergebnis vom Überschreiten der Anzahl zulässiger Links für den Meldungsblock sein oder das Ergebnis von Versuchen, ein bestimmtes Ziel zweimal mit der gleichen Quelle zu verknüpfen.
invalid_multiple_scheduling-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn ein `task_handle`-Objekt mehrmals mittels der `run`-Methode eines `task_group`-Objekts oder `structured_task_group`-Objekts ohne einen zwischenzeitlichen Aufruf der `wait`-Methode oder `run_and_wait`-Methode geplant wird.
Klasse invalid_operation	Diese Klasse beschreibt eine Ausnahme, die bei Ausführen einer ungültigen Operation ausgelöst wird, die nicht genauer von einem anderen von der Concurrency Runtime ausgelösten Ausnahmetyp beschrieben wird.
invalid_oversubscribe_operation Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn die `Context::Oversubscribe`-Methode mit dem auf `_BeginOversubscription` festgelegten `false`-Parameter ohne einen vorherigen Aufruf der `Context::Oversubscribe`-Methode mit dem auf `_BeginOversubscription` festgelegten `true`-Parameter aufgerufen wird.
InvalidSchedulerPolicyKey-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn ein ungültiger oder unbekannter Schlüssel an einen `SchedulerPolicy`-Objektkonstruktor übergeben wird, oder wenn der `SetPolicyValue`-Methode eines `SchedulerPolicy`-Objekts ein Schlüssel übergeben wird, der auf andere Weise geändert werden muss, z. B. die `SetConcurrencyLimits`-Methode.
invalid scheduler policy thread specification Klasse	Diese Klasse beschreibt eine Ausnahme, die bei dem Versuch ausgelöst wird, die Parallelitätsgrenzen eines `SchedulerPolicy`-Objekts so festzulegen, dass der Wert des `MinConcurrency`-Schlüssels kleiner ist, als der Wert des `MaxConcurrency`-Schlüssels.
invalidschedulerpolicyvalue-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn der Richtlinienschlüssel eines `SchedulerPolicy`-Objekts auf einen ungültigen Wert für diesen Schlüssel festgelegt wird.
ISource-Klasse	Die `ISource`-Klasse ist die Schnittstelle für alle Quellblöcke. Quellblöcke geben Meldungen an `ITarget`-Blöcke weiter.
ITarget-Klasse	Die `ITarget`-Klasse ist die Schnittstelle für alle Zielblöcke. Zielblöcke empfangen die von `ISource`-Blöcken angebotenen Meldungen.
join Class	Ein `join`-Meldungsblock ist ein geordneter `propagator_block` mit mehreren Quellen und einem einzelnen Ziel, der Meldungen vom Typ `T` aus allen Quellen kombiniert.
Location-Klasse	Die Abstraktion eines physischen Speicherorts auf der Hardware.
Message-Klasse	Der grundlegende Nachrichtenumschlag, der die zwischen den Meldungsblöcken übergebene Datennutzlast enthält.
message_not_found-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn ein Meldungsblock keine angeforderte Meldung finden kann.
message_processor-Klasse	Die `message_processor`-Klasse ist die abstrakte Basisklasse für die Verarbeitung von `message`-Objekten. Für die Reihenfolge der Meldungen besteht keine Garantie.
MissingWait-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn während der Ausführung des Destruktors eines Objekts noch Aufgaben für ein `task_group`-Objekt oder `structured_task_group`-Objekt geplant sind. Diese Ausnahme wird nie ausgelöst, wenn der Destruktor aufgrund einer Stapelentladung als Ergebnis einer Ausnahme erreicht wird.
multi_link_registry-Klasse	Das `multi_link_registry`-Objekt ist eine `network_link_registry`, die mehrere Quellblöcke oder mehrere Zielblöcke verwaltet.
multitype_join-Klasse	Ein `multitype_join`-Meldungsblock ist ein Block mit mehreren Quellen und einem einzelnen Ziel, der Meldungen verschiedener Typen aus allen Quellen kombiniert und dem Ziel ein Tupel der kombinierten Meldungen bereitstellt.
nested_scheduler_missing_detach-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn die Concurrency Runtime erkennt, dass versäumt wurde, die `CurrentScheduler::Detach`-Methode für einen Kontext aufzurufen, der mittels der `Attach`-Methode des `Scheduler`-Objekts an einen zweiten Planer angefügt wurde.
network_link_registry-Klasse	Die abstrakte `network_link_registry`-Basisklasse verwaltet die Verknüpfung zwischen Quell- und Zielblöcken.
operation_timed_out-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn das Timeout einer Operation erreicht wurde.
Ordered_Message_Processor-Klasse	Ein `ordered_message_processor` ist ein `message_processor`, mit dem Meldungsblöcke Meldungen in der Reihenfolge verarbeiten können, in der sie empfangen wurden.
overwrite_buffer-Klasse	Ein `overwrite_buffer`-Meldungsblock ist ein geordneter `propagator_block` mit mehreren Zielen und mehreren Quellen, der jeweils eine einzelne Meldung speichern kann. Neue Meldungen überschreiben zuvor Gespeicherte.
progress_reporter-Klasse	Die Fortschrittsmelder-Klasse ermöglicht das Melden von Fortschrittsbenachrichtigungen eines bestimmten Typs. Jedes progress_reporter-Objekt ist an eine bestimmte asynchrone Aktion bzw. einen Vorgang gebunden.
PropagatorBlock-Klasse	Die `propagator_block`-Klasse ist eine abstrakte Basisklasse für Meldungsblöcke, die sowohl Quelle als auch Ziel sind. Kombiniert die Funktion der `source_block`-Klasse mit der Funktion der `target_block`-Klasse.
Reader-Writer-Lock-Klasse	Eine warteschlangenbasierte Lese-/Schreibsperre mit Schreibervorrang und ausschließlich lokalem Spinning. Die Sperre gewährt Schreiberzugriff nach dem "First In, First Out"-Prinzip (FIFO) und benachteiligt Leser unter einer fortlaufenden Last von Schreibern.
ScheduleGroup-Klasse	Stellt eine Abstraktion für eine Planungsgruppe dar. In Planungsgruppen werden Sätze verwandter Arbeitsaufgaben organisiert, die von einer gemeinsamen Planung profitieren. Die kann entweder zeitlich durch das Ausführen einer anderen Aufgabe in der gleichen Gruppe vor dem Wechsel in eine andere Gruppe, oder räumlich durch das Ausführen mehrerer Elemente innerhalb der gleichen Gruppe auf dem gleichen NUMA-Knoten oder physischem Socket geschehen.
Scheduler-Klasse	Stellt eine Abstraktion für einen Concurrency Runtime-Planer dar.
scheduler_not_attached Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn ein Vorgang ausgeführt wird, der erfordert, dass ein Planer an den aktuellen Kontext angefügt wird, und keiner angefügt ist.
scheduler_resource_allocation_error-Klasse	Diese Klasse beschreibt eine Ausnahme, die aufgrund eines Fehlers beim Erwerb einer kritischen Ressource in der Concurrency Runtime geworfen wird.
scheduler_worker_creation_error-Klasse	Diese Klasse beschreibt eine Ausnahme, die aufgrund eines Fehlers bei der Erstellung eines Worker-Ausführungskontextes in der Concurrency Runtime ausgelöst wird.
SchedulerPolicy-Klasse	Die `SchedulerPolicy`-Klasse enthält einen Satz von Schlüssel-Wert-Paaren. Einen für jedes Richtlinienelement, von dem das Verhalten einer Planerinstanz gesteuert wird.
simple_partitioner-Klasse	Die `simple_partitioner`-Klasse stellt eine statische Partitionierung des Bereichs dar, der von `parallel_for` durchlaufen wird. Mit dem Partitionierer wird der Bereich in Blöcke unterteilt, sodass jeder Block mindestens die von der Segmentgröße angegebene Anzahl von Iterationen enthält.
single_assignment-Klasse	Ein `single_assignment`-Meldungsblock ist ein geordneter `propagator_block` mit mehreren Zielen und mehreren Quellen, der eine einzelne, einmal beschreibbare `message` speichern kann.
single_link_registry-Klasse	Das `single_link_registry`-Objekt ist eine `network_link_registry`, die nur eine einzige Quelle oder einen einzigen Zielblock verwaltet.
SourceBlock-Klasse	Die `source_block`-Klasse ist eine abstrakte Basisklasse ausschließlich für Quellblöcke. Die Klasse stellt grundlegende Linkmanagementfunktionalität sowie allgemeine Fehlerüberprüfungen bereit.
source_link_manager-Klasse	Das `source_link_manager`-Objekt verwaltet Meldungsblock-Netzwerklinks zu `ISource`-Blöcken.
static_partitioner-Klasse	Die `static_partitioner`-Klasse stellt eine statische Partitionierung des Bereichs dar, der von `parallel_for` durchlaufen wird. Der Partitioner teilt den Bereich in so viele Blöcke auf, wie für den zugrunde liegenden Planer Arbeitskräfte verfügbar sind.
structured_task_group-Klasse	Die `structured_task_group`-Klasse stellt eine stark strukturierte Auflistung paralleler Arbeit dar. Sie können einzelne parallele Aufgaben mithilfe von `structured_task_group`-Objekten in eine Warteschlange `task_handle` stellen und abwarten, bis sie abgeschlossen sind, oder die Aufgabenliste abbrechen, bevor deren Ausführung beendet ist. Dadurch werden auch alle Aufgaben abgebrochen, deren Ausführung noch nicht begonnen wurde.
target_block-Klasse	Die `target_block`-Klasse ist eine abstrakte Basisklasse, mit der grundlegende Linkmanagementfunktionalität und Fehlerüberprüfung für Nur-Ziel-Blöcke bereitgestellt werden.
task-Klasse (Concurrency Runtime)	Die Parallel Patterns Library (PPL) `task`-Klasse. Ein `task`-Objekt stellt Arbeit dar, die asynchron und gleichzeitig mit anderen Tasks sowie mit paralleler Arbeit, die durch parallele Algorithmen in der Concurrency Runtime erzeugt wird, ausgeführt werden kann. Es erzeugt bei erfolgreichem Abschluss ein Ergebnis vom Typ `_ResultType`. Tasks des Typs `task<void>` führen zu keinem Ergebnis. Eine Aufgabe kann abgewartet und unabhängig von anderen Aufgaben abgebrochen werden. Er kann mit anderen Tasks mithilfe von Continuations (`then`) sowie Join-Muster (`when_all`) und Choise-Muster (`when_any`) erstellt werden.
task_canceled Klasse	Diese Klasse beschreibt eine Ausnahme, die von der PPL-Aufgabenschicht ausgelöst wird, um die aktuelle Aufgabe abzubrechen. Es wird auch von der `get()` Methode bei einer abgebrochenen Aufgabe ausgelöst.
task_completion_event-Klasse	Mit der `task_completion_event`-Klasse können Sie die Ausführung einer Aufgabe verzögern, bis eine Bedingung erfüllt ist, oder eine Aufgabe als Reaktion auf ein externes Ereignis starten.
task_continuation_context Klasse	Mit der `task_continuation_context`-Klasse können Sie angeben, an welcher Stelle eine Fortsetzung ausgeführt werden soll. Es ist nur hilfreich, diese Klasse aus einer UWP-App zu verwenden. Bei Nicht-Windows-Runtime-Apps wird der Ausführungskontext der Aufgabenfortsetzung durch die Laufzeit bestimmt und nicht konfigurierbar.
task_group-Klasse	Die `task_group`-Klasse stellt eine Sammlung paralleler Arbeiten dar, auf die gewartet oder die abgebrochen werden können.
task_handle-Klasse	Die `task_handle`-Klasse stellt ein einzelnes paralleles Arbeitselement dar. Sie kapselt die Anweisungen und die zum Ausführen eines Teils der Arbeit erforderlichen Daten.
task_options-Klasse (Concurrency Runtime)	Stellt die zulässigen Optionen zum Erstellen einer Aufgabe dar
timer-Klasse	Ein `timer`-Meldungsblock ist ein `source_block` mit einem einzelnen Ziel, der nach Ablauf einer bestimmten Zeitspanne oder in bestimmten Intervallen eine Meldung an sein Ziel senden kann.
transformer-Klasse	Ein `transformer`-Meldungsblock ist ein geordneter `propagator_block` mit einem einzelnen Ziel und mehreren Quellen, der Meldungen eines Typs akzeptieren und eine unbegrenzte Anzahl von Meldungen eines anderen Typs speichern kann.
UnboundedBuffer-Klasse	Ein `unbounded_buffer`-Meldungsblock ist ein geordneter `propagator_block` mit mehreren Zielen und mehreren Quellen, der eine unbegrenzte Anzahl von Meldungen speichern kann.
unsupported_os-Klasse	Diese Klasse beschreibt eine Ausnahme, die ausgelöst wird, wenn ein nicht unterstütztes Betriebssystem verwendet wird.

Strukturen

Name	Beschreibung
DispatchState-Struktur	Die `DispatchState`-Struktur wird zur Zustandsübertragung auf die `IExecutionContext::Dispatch`-Methode verwendet. Sie beschreibt die Umstände, unter denen die `Dispatch`-Methode für eine `IExecutionContext`-Schnittstelle aufgerufen wird.
IExecutionContext-Struktur	Eine Schnittstelle zu einem Ausführungskontext, der auf einem angegebenen virtuellen Prozessor ausgeführt werden kann und einen gemeinsamen Kontextwechsel zulässt.
IExecutionResource-Struktur	Eine Abstraktion für einen Hardwarethread.
IResourceManager-Struktur	Eine Schnittstelle zum Ressourcen-Manager der Concurrency Runtime. Dies ist die Schnittstelle, über die Planer mit dem Ressourcen-Manager kommunizieren.
IScheduler-Struktur	Eine Schnittstelle zu der Abstraktion eines Arbeitsplaners. Der Ressourcen-Manager der Concurrency Runtime kommuniziert mithilfe dieser Schnittstelle mit Arbeitsplanern.
ISchedulerProxy-Struktur	Die Schnittstelle, über die Planer mit dem Ressourcen-Manager der Concurrency Runtime kommunizieren, um die Ressourcenzuordnung auszuhandeln.
IThreadProxy-Struktur	Eine Abstraktion für einen Ausführungsthread. Abhängig vom `SchedulerType`-Richtlinienschlüssel des von Ihnen erstellten Planers gewährt der Ressourcen-Manager einen Thread-Proxy, der entweder von einem regulären Win32-Thread oder einem planbaren Benutzermodus-Thread (UMS) unterstützt wird. UMS-Threads werden auf 64-Bit-Betriebssystemen mit Version Windows 7 und höher unterstützt.
ITopologyExecutionResource-Struktur	Eine Schnittstelle zu einer vom Ressourcen-Manager definierten Ausführungsressource.
ITopologyNode-Struktur	Eine Schnittstelle für einen vom Ressourcen-Manager definierten Topologieknoten. Ein Knoten enthält mindestens eine Ausführungsressource.
IUMSCompletionList-Struktur	Stellt eine UMS-Vervollständigungsliste dar. Wenn ein UMS-Thread blockiert, wird der zugewiesene Planungskontext des Schedulers ausgeführt, um zu entscheiden, was auf dem zugrunde liegenden virtuellen Prozessorstamm ausgeführt werden soll, während der ursprüngliche Thread blockiert ist. Wenn die Blockierung des ursprünglichen Threads aufgehoben wird, stellt das Betriebssystem ihn in die Warteschlange für die Vervollständigungsliste, auf die über diese Schnittstelle zugegriffen werden kann. Der Scheduler kann die Abschlussliste im festgelegten Planungskontext oder an einer beliebigen anderen Position abfragen, an der er nach Arbeit sucht.
IUMSScheduler-Struktur	Eine Schnittstelle zu der Abstraktion eines Arbeitsplaners, der planbare Threads vom Ressourcen-Manager der Concurrency Runtime im Benutzermodus erwartet. Der Ressourcen-Manager verwendet diese Schnittstelle für die Kommunikation mit UMS-Threadplanern. Die `IUMSScheduler` -Schnittstelle erbt von der `IScheduler` -Schnittstelle.
IUMSThreadProxy-Struktur	Eine Abstraktion für einen Ausführungsthread. Wenn dem Planer im Benutzermodus planbare (UMS) Threads gewährt werden sollen, legen Sie den Wert für das Planerrichtlinienelement `SchedulerKind` auf `UmsThreadDefault` fest, und implementieren Sie die `IUMSScheduler`-Schnittstelle. UMS-Threads werden nur unter 64-Bit-Betriebssystemen mit Version Windows 7 und höher unterstützt.
IUMSUnblockNotification-Struktur	Stellt eine Benachrichtigung vom Ressourcen-Manager darüber dar, dass ein Thread-Proxy, der blockiert war und die Rückkehr zum festgelegten Planungskontext des Planers ausgelöst hat, entblockiert ist und bereit zum Planen ist. Diese Schnittstelle ist ungültig, sobald der zugeordnete Ausführungskontext des Threadproxys, der von der `GetContext`-Methode zurückgegeben wurde, neu geplant wird.
IVirtualProcessorRoot-Struktur	Eine Abstraktion für einen Hardwarethread, auf dem ein Threadproxy ausgeführt werden kann.
scheduler_interface-Struktur	Planerschnittstelle
scheduler_ptr-Struktur (Concurrency Runtime)	Stellt einen Zeiger auf einen Planer dar. Diese Klasse dient dazu, die Spezifikation einer geteilten Lebensdauer mithilfe von shared_ptr oder nur eines einfachen Verweises mithilfe eines Rohzeigers zu ermöglichen.

Enumerationen

Name	Beschreibung
agent_status	Die gültigen Zustände für einen `agent`.
Agents_Ereignistyp	Arten von Ereignissen, die mit der von der Agents Library angebotenen Tracing-Funktion verfolgt werden können
ConcRT_EventType	Die Typen von Ereignissen, die mit der von der Concurrency Runtime angebotenen Ablaufverfolgungsfunktionalität aufgezeichnet werden können.
Concrt_TraceFlags	Spurkennzeichen für Typen von Ereignissen
CriticalRegionType	Der Typ eines kritischen Bereichs, in dem sich ein Kontext befindet.
DynamicProgressFeedbackType	Wird von der `DynamicProgressFeedback`-Richtlinie verwendet, um zu beschreiben, ob Ressourcen für den Planer anhand der statistischen Informationen, die vom Planer erfasst wurden, oder nur auf Grundlage der Zustände virtueller Prozessoren, die durch die Aufrufe der `Activate`- und `Deactivate`-Methoden auf der `IVirtualProcessorRoot`-Schnittstelle in den und aus dem Leerlauf wechseln, neu verteilt werden. Weitere Informationen zu verfügbaren Zeitplanrichtlinien finden Sie unter PolicyElementKey.
join_type	Der Typ eines `join`-Meldungsblocks.
message_status	Die gültigen Antworten für eine Bereitstellung eines `message`-Objekts für einen Block.
PolicyElementKey	Richtlinienschlüssel, die Aspekte des Planerverhaltens beschreiben. Jedes Richtlinienelement wird mit einem Schlüssel-Wert-Paar beschrieben. Weitere Informationen zu Zeitplanrichtlinien und deren Auswirkungen auf Planer finden Sie unter "Task Scheduler".
SchedulerType	Wird von der `SchedulerKind`-Richtlinie verwendet, um den Typ der Threads zu beschreiben, die der Planer für zugrunde liegende Ausführungskontexte verwenden soll. Weitere Informationen zu verfügbaren Zeitplanrichtlinien finden Sie unter PolicyElementKey.
SchedulingProtocolType	Wird von der `SchedulingProtocol`-Richtlinie verwendet, um zu beschreiben, welcher Planungsalgorithmus für den Planer verwendet wird. Weitere Informationen zu verfügbaren Zeitplanrichtlinien finden Sie unter PolicyElementKey.
SwitchingProxyState	Wird verwendet, um den Zustand zu bezeichnen, in dem sich ein Threadproxy befindet, wenn er einen kooperativen Kontextwechsel zu einem anderen Threadproxy ausführt.
Aufgaben_Gruppen_Status	Beschreibt den Ausführungsstatus eines `task_group`-Objekts oder eines `structured_task_group`-Objekts. Ein Wert dieses Typs wird von zahlreichen Methoden zurückgegeben, die auf den Abschluss von Aufgaben warten, die für eine Aufgabengruppe geplant wurden.
WinRTInitializationType	Wird von der `WinRTInitialization`-Richtlinie verwendet, um zu beschreiben, ob und wie die Windows Runtime auf Scheduler-Threads für eine Anwendung initialisiert wird, die auf Windows-Betriebssystemen ab Version 8 oder höher ausgeführt wird. Weitere Informationen zu verfügbaren Zeitplanrichtlinien finden Sie unter PolicyElementKey.

Funktionen

Name	Beschreibung
Alloc-Funktion	Reserviert einen Speicherblock von der im Zwischenspeicher-Suballocator der Concurrency Runtime angegebenen Größe.
asend-Funktion	Überladen. Ein asynchroner Sendevorgang, der eine Aufgabe zum Weitergeben der Daten an den Zielblock plant.
cancel_current_task-Funktion	Bricht die gerade ausgeführte Aufgabe ab. Diese Funktion kann aus dem Text einer Aufgabe aufgerufen werden, um die Ausführung der Aufgabe abzubrechen und ihn dabei in den `canceled` Zustand übergehen zu lassen. Der Aufruf dieser Funktion, wenn Sie sich nicht innerhalb des Körpers eines `task` befinden, ist kein unterstütztes Szenario. Dies führt zu einem undefinierten Verhalten, z. B. zu einem Absturz oder einer Unresponsivität in Ihrer Anwendung.
create_async-Funktion	Erstellt ein asynchrones Konstrukt der Windows Runtime basierend auf einem vom Benutzer angegebenen Lambda oder Funktionsobjekt. Der Rückgabetyp von `create_async` ist entweder `IAsyncAction^`, `IAsyncActionWithProgress<TProgress>^`, `IAsyncOperation<TResult>^` oder `IAsyncOperationWithProgress<TResult, TProgress>^` auf Grundlage der Signatur des Lambda-Ausdrucks, der an die Methode übergeben wurde.
create_task-Funktion	Überladen. Erstellt ein PPL-Aufgabenobjekt. Das Element `create_task` kann überall dort verwendet werden, wo Sie einen Aufgabenkonstruktor verwendet hätten. Es wird hauptsächlich der Einfachheit halber bereitgestellt, da es beim Erstellen eines Tasks die Verwendung des `auto`-Schlüsselwort ermöglicht.
CreateResourceManager-Funktion	Gibt eine Schnittstelle zurück, die die Singletoninstanz des Ressourcen-Managers der Concurrency Runtime darstellt. Der Ressourcen-Manager ist für das Zuweisen von Ressourcen für Planer, die miteinander kooperieren möchten, zuständig.
DisableTracing-Funktion	Deaktiviert die Ablaufverfolgung in der Concurrency Runtime. Diese Funktion ist veraltet, da die ETW-Ablaufverfolgung standardmäßig nicht registriert ist.
EnableTracing-Funktion	Aktiviert die Ablaufverfolgung in der Concurrency Runtime. Diese Funktion ist veraltet, da die ETW-Ablaufverfolgung jetzt standardmäßig aktiviert ist.
Kostenlose Funktion	Gibt einen zuvor von der `Alloc`-Methode des Caching-Suballocators der Concurrency Runtime reservierten Speicherblock frei.
get_ambient_scheduler-Funktion (Concurrency Runtime)
GetExecutionContextId-Funktion	Gibt einen eindeutigen Bezeichner zurück, der einem Ausführungskontext zugewiesen werden kann, der die `IExecutionContext`-Schnittstelle implementiert.
GetOSVersion-Funktion	Gibt die Betriebssystemversion zurück.
GetProcessorCount-Funktion	Gibt die Anzahl von Hardwarethreads des zugrunde liegenden Systems zurück.
GetProcessorNodeCount-Funktion	Gibt die Anzahl von NUMA-Knoten oder Prozessorpaketen des zugrunde liegenden Systems zurück.
GetSchedulerId-Funktion	Gibt einen eindeutigen Bezeichner zurück, der einem Planer zugewiesen werden kann, der die `IScheduler`-Schnittstelle implementiert.
interruption_point-Funktion	Erstellt einen Unterbrechungspunkt zum Abbrechen. Wenn im Kontext, in dem diese Funktion aufgerufen wird, ein Abbruch im Gange ist, wird eine interne Ausnahme ausgelöst, die die Ausführung der aktuell laufenden parallelen Arbeit abbricht. Wenn der Abbruch nicht im Gange ist, tut die Funktion nichts.
is_current_task_group_canceling-Funktion	Gibt zurück, ob die Aufgabengruppe, die derzeit inline im aktuellen Kontext ausgeführt wird, sich mitten in einer aktiven Stornierung befindet (oder sich kurz davor befindet). Beachten Sie, dass `false` zurückgegeben wird, wenn aktuell im aktuellen Kontext keine Aufgabengruppe inline ausgeführt wird.
make_choice-Funktion	Überladen. Erstellt einen `choice`-Meldungsblock aus einem optionalen `Scheduler` oder `ScheduleGroup` und mindestens zwei Eingabequellen.
make_greedy_join -Funktion	Überladen. Erstellt einen `greedy multitype_join`-Meldungsblock aus einem optionalen `Scheduler` oder `ScheduleGroup` und mindestens zwei Eingabequellen.
make_join-Funktion	Überladen. Erstellt einen `non_greedy multitype_join`-Meldungsblock aus einem optionalen `Scheduler` oder `ScheduleGroup` und mindestens zwei Eingabequellen.
make_task-Funktion	Eine Factory-Methode zum Erstellen eines `task_handle`-Objekts.
parallel_buffered_sort-Funktion	Überladen. Ordnet die Elemente in einem angegebenen Bereich in einer nicht absteigenden Reihenfolge oder nach einem durch ein binäres Prädikat angegebenen Sortierkriterium parallel an. Diese Funktion entspricht `std::sort` semantisch darin, dass sie eine vergleichsbasierte, instabile Sortierung vor Ort ist, abgesehen von dem zusätzlich erforderlichen `O(n)`-Speicherplatz und der notwendigen Standardinitialisierung für die sortierten Elemente.
parallel_for-Funktion	Überladen. `parallel_for` durchläuft einen Bereich von Indizes und führt bei jeder Iteration parallel eine vom Benutzer bereitgestellte Funktion aus.
parallel_for_each-Funktion	Überladen. `parallel_for_each` wendet eine angegebene Funktion parallel auf jedes Element innerhalb eines Bereichs an. Sie entspricht semantisch der `for_each`-Funktion im `std`-Namespace, außer dass die Iteration über die Elemente parallel ausgeführt wird und die Reihenfolge der Iteration nicht angegeben ist. Das Argument `_Func` muss einen Funktionsaufrufoperator in der Form `operator()(T)` unterstützen, wobei der Parameter `T` der Elementtyp des durchlaufenen Containers ist.
parallel_invoke-Funktion	Überladen. Führt die als Parameter angegebenen Funktionsobjekte parallel aus, und blockiert, bis die Ausführung beendet ist. Jedes Funktionsobjekt kann ein Lambdaausdruck, ein Zeiger auf eine Funktion oder ein anderes Objekt sein, das den Funktionsaufrufoperator mit der Signatur `void operator()()` unterstützt.
parallel_radixsort-Funktion	Überladen. Ordnet Elemente in einem angegebenen Bereich mithilfe eines Radix-Sortieralgorithmus in einer nicht absteigenden Reihenfolge an. Dies ist eine stabile Sortierfunktion, die eine Projektionsfunktion erfordert, mit der Elemente zur Sortierung in Schlüssel, die ganzen Zahlen ohne Vorzeichen ähneln, projiziert werden können. Standardinitialisierung ist für die zu sortierenden Elemente erforderlich.
parallel_reduce-Funktion	Überladen. Berechnet die Summe aller Elemente in einem angegebenen Bereich, indem aufeinander folgende Teilsummen berechnet werden, oder berechnet das Ergebnis der aufeinander folgenden Teilergebnisse, die auf ähnliche Weise mithilfe eines angegebenen binären Vorgangs (außer Summe) abgerufen werden parallel. `parallel_reduce` entspricht `std::accumulate` semantisch, außer dass der binäre Vorgang assoziativ sein muss und ein Identitätswert anstelle eines Anfangswerts erforderlich ist.
parallel_sort-Funktion	Überladen. Ordnet die Elemente in einem angegebenen Bereich in einer nicht absteigenden Reihenfolge oder nach einem durch ein binäres Prädikat angegebenen Sortierkriterium parallel an. Diese Funktion entspricht `std::sort` semantisch insofern, dass sie eine vergleichsbasierte, instabile, direkte Sortierung ist.
parallel_transform-Funktion	Überladen. Wendet ein angegebenes Funktionsobjekt auf jedes Element in einem Quellbereich oder auf ein Elementpaar aus zwei Quellbereichen an und kopiert die Rückgabewerte des Funktionsobjekts parallel in einen Zielbereich. Diese Funktion entspricht semantisch `std::transform`.
Receive-Funktion	Überladen. Eine allgemeine Empfangsimplementierung, mit der ein Kontext auf Daten von genau einer Quelle warten und die akzeptierten Werte filtern kann.
run_with_cancellation_token-Funktion	Führt sofort synchron ein Funktionsobjekt im Kontext eines angegebenen Abbruchtokens aus.
send-Funktion	Überladen. Ein synchroner Sendevorgang, der wartet, bis das Ziel die Meldung akzeptiert oder ablehnt.
set_ambient_scheduler-Funktion (Parallelitätslaufzeit)
set_task_execution_resources-Funktion	Überladen. Schränkt die Ausführungsressourcen, die von den internen Arbeitsthreads der Concurrency Runtime verwendet werden, auf den angegebenen Affinitätssatz ein. Es ist gültig, diese Methode nur aufzurufen, bevor der Ressourcen-Manager erstellt wird oder zwischen den Lebensdauern von zwei Ressourcen-Managern. Sie kann mehrmals aufgerufen werden, solange der Ressourcen-Manager zum Zeitpunkt des Aufrufs nicht vorhanden ist. Nachdem eine Affinitätsgrenze eingerichtet wurde, bleibt diese bis zum nächsten gültigen Aufruf der `set_task_execution_resources`-Methode bestehen. Die bereitgestellte Affinitätsmaske muss keine Teilmenge der Prozessaffinitätsmaske sein. Die Prozessaffinität wird bei Bedarf aktualisiert.
swap-Funktion	Tauscht die Elemente zweier `concurrent_vector`-Objekte.
task_from_exception-Funktion (Concurrency Runtime)
task_from_result-Funktion (Parallelitätslaufzeit)
Trace_agents_register_name-Funktion	Ordnet den angegebenen Namen einem Nachrichtenblock oder Agenten in ETW-Trace zu.
try_receive-Funktion	Überladen. Eine allgemeine try-receive-Implementierung, mit der ein Kontext Daten von genau einer Quelle suchen und die akzeptierten Werte filtern kann. Wenn die Daten nicht bereit sind, gibt die Methode "false" zurück.
wait-Funktion	Hält den aktuellen Kontext für eine bestimmte Zeit an.
when_all-Funktion	Erstellt eine Aufgabe, die erfolgreich abgeschlossen wird, wenn alle als Argumente angegeben Aufgaben erfolgreich abgeschlossen werden.
when_any-Funktion	Überladen. Erstellt eine Aufgabe, die erfolgreich abgeschlossen wird, wenn eine der als Argumente angegeben Aufgaben erfolgreich abgeschlossen wird.

Operatoren

Name	Beschreibung
operator!=	Testet, ob das `concurrent_vector`-Objekt links vom Operator ungleich dem `concurrent_vector`-Objekt rechts vom Operator ist.
operator&&	Überladen. Erstellt eine Aufgabe, die erfolgreich abgeschlossen wird, wenn beide als Argumente bereitgestellten Vorgänge erfolgreich abgeschlossen werden.
`operator\|\|`	Überladen. Erstellt eine Aufgabe, die erfolgreich abgeschlossen wird, wenn eine der als Argumente angegeben Aufgaben erfolgreich abgeschlossen wird.
Operator<	Testet, ob das `concurrent_vector`-Objekt links vom Operator kleiner als das `concurrent_vector`-Objekt auf der rechten Seite ist.
operator<=	Testet, ob das `concurrent_vector`-Objekt links vom Operator kleiner oder gleich dem `concurrent_vector`-Objekt auf der rechten Seite ist.
operator==	Testet, ob das `concurrent_vector`-Objekt links vom Operator gleich dem `concurrent_vector`-Objekt rechts vom Operator ist.
Operator>	Testet, ob das `concurrent_vector`-Objekt links vom Operator größer als das `concurrent_vector`-Objekt auf der rechten Seite ist.
operator>=	Testet, ob das `concurrent_vector`-Objekt links vom Operator größer oder gleich dem `concurrent_vector`-Objekt auf der rechten Seite ist.

Konstanten

Name	Beschreibung
AgentEventGuid	Ein Kategorie-GUID ({B9B5B78C-0713-4898-A21A-C67949DCED07}), der ETW-Ereignisse beschreibt, die von der Agents-Bibliothek in der Concurrency-Runtime ausgelöst werden.
ChoreEventGuid	Ein Kategorie-GUID, die ETW-Ereignisse beschreibt, die von der Concurrency Runtime ausgelöst werden und sich direkt auf Aufgaben oder Tätigkeiten beziehen.
ConcRT_ProviderGuid	Der ETW-Anbieter-GUID für die Concurrency Runtime.
CONCRT_RM_VERSION_1	Gibt die Unterstützung der in Visual Studio 2010 definierten Ressourcen-Manager-Schnittstelle an.
ConcRTEventGuid	Eine Kategorie-GUID, der ETW-Ereignisse beschreibt, die von der Concurrency Runtime ausgelöst werden und nicht spezifischer von einer anderen Kategorie beschrieben werden.
ContextEventGuid	Ein Kategorie-GUID, die ETW-Ereignisse beschreibt, die von der Concurrency Runtime ausgelöst werden und sich direkt auf Kontexte beziehen.
COOPERATIVE_TIMEOUT_INFINITE	Ein Wert, der angibt, dass ein Wartevorgang nie durch einen Timeout beendet werden sollte.
COOPERATIVE_WAIT_TIMEOUT	Ein Wert, der angibt, dass ein Wartevorgang durch einen Timeout beendet wurde.
INHERIT_THREAD_PRIORITY	Ein besonderer Wert für den Richtlinienschlüssel `ContextPriority`, der angibt, dass die Threadpriorität aller Kontexte im Planer die gleiche wie die des Threads sein sollte, der den Planer erstellt hat.
LockEventGuid	Eine Kategorie-GUID, die ETW-Ereignisse beschreibt, die von der Concurrency Runtime ausgelöst werden und sich direkt auf Sperren beziehen.
MaxExecutionResources	Ein besonderer Wert für die Richtlinienschlüssel `MinConcurrency` und `MaxConcurrency`. Wird standardmäßig auf die Anzahl der Hardware-Threads auf dem Computer festgelegt, falls keine anderen Einschränkungen vorliegen.
PPLParallelForeachEventGuid	Ein Kategorie-GUID, die ETW-Ereignisse beschreibt, die von der Concurrency Runtime ausgelöst werden und sich direkt auf die Verwendung der `parallel_for_each`-Funktion beziehen.
PPLParallelForEventGuid	Ein Kategorie-GUID, die ETW-Ereignisse beschreibt, die von der Concurrency Runtime ausgelöst werden und sich direkt auf die Verwendung der `parallel_for`-Funktion beziehen.
PPLParallelInvokeEventGuid	Ein Kategorie-GUID, die ETW-Ereignisse beschreibt, die von der Concurrency Runtime ausgelöst werden und sich direkt auf die Verwendung der `parallel_invoke`-Funktion beziehen.
ResourceManagerEventGuid	Ein Kategorie-GUID, die ETW-Ereignisse beschreibt, die von der Concurrency Runtime ausgelöst werden und sich direkt auf den Ressourcen-Manager beziehen.
ScheduleGroupEventGuid	Eine Kategorie-GUID, die ETW-Ereignisse beschreibt, welche von der Concurrency Runtime ausgelöst werden und sich direkt auf Planungsgruppen beziehen.
SchedulerEventGuid	Eine GUID für eine Kategorie, die ETW-Ereignisse beschreibt, die von der Concurrency Runtime generiert werden und sich direkt auf Aktivitäten des Schedulers beziehen.
VirtualProcessorEventGuid	Ein Kategorie-GUID, die ETW-Ereignisse beschreibt, die von der Concurrency Runtime ausgelöst werden und sich direkt auf virtuelle Prozessoren beziehen.

Anforderungen

Header: agents.h, concrt.h, concrtrm.h, concurrent_priority_queue.h, concurrent_queue.h, concurrent_unordered_map.h, concurrent_unordered_set.h, concurrent_vector.h, internal_concurrent_hash.h, internal_split_ordered_list.h, ppl.h, pplcancellation_token.h, pplconcrt.h, pplinterface.h, ppltasks.h

Siehe auch

Referenz

Feedback

War diese Seite hilfreich?

Last updated on 2025-11-07