Porovnávání synchronizačních datových struktur s rozhraním API systému Windows

Článek
06/09/2015

Toto téma porovnává chování synchronizace struktury dat, které poskytuje modul Runtime souběžnosti uvedeným rozhraním API systému Windows.

Proveďte synchronizaci datových struktur, které poskytuje modul Runtime souběžnosti modelem spolupráce.V kooperativní model podprocesů synchronizační primitiva výnos explicitně své prostředky zpracování jiných podprocesů.Tím se liší od preemptivní model podprocesu, kde přeneseno zatěžují jiné podprocesy řízení plánovače nebo operačního systému.

critical_section

Concurrency::critical_section třída připomíná Windows CRITICAL_SECTION struktury, protože může být používán pouze podprocesy jednoho procesu.Další informace o kritických sekcích v rozhraní API systému Windows naleznete v tématu Objekty důležité část.

reader_writer_lock

Concurrency::reader_writer_lock třída připomíná zámky slim reader/writer (SRW) systému Windows.Následující tabulka vysvětluje rozdíly a podobnosti.

Funkce	reader_writer_lock	SRW zámku
Non-vícenásobně přístupné	Ano	Ano
Může podporovat čtenáře Writer (podpora upgradu)	Ne	Ne
Můžete snížit úroveň Zapisovatel do čtečky (podpora downgrade)	Ne	Ne
Zápis předvoleb zámek	Ano	Ne
Přístup FIFO pro autory	Ano	Ne

Další informace o uzamčení SRW, viz Slim Reader/Writer (SRW) zámky v sadě Platform SDK.

událost

Concurrency::event třída připomíná událost nepojmenované, ruční obnovení systému Windows.Nicméně event objekt se chová kooperativně, že preventivně se chová událostí systému Windows.Další informace o událostech systému Windows naleznete v tématu Objekty událostí.

Příklad

Description

Chcete-li lépe pochopit rozdíl mezi event třídy a událostí systému Windows, zvažte následující příklad.Tento příklad povolí plánovač vytvořit maximálně dvě souběžné úlohy a pak dvě podobné funkce, které používají volání event třídy a k události ruční obnovení systému Windows.Každá funkce nejprve vytvoří několik úkolů, které čekání na sdílené událost stane signalizována.Každá funkce pak vede k spuštěných úloh a poté signály události.Každá funkce je pak čeká signalizovaném událost.

Kód

// event-comparison.cpp 
// compile with: /EHsc
#include <windows.h>
#include <concrtrm.h>
#include <ppl.h>
#include <iostream>
#include <sstream>

using namespace concurrency;
using namespace std;

// Demonstrates the usage of cooperative events. 
void RunCooperativeEvents()
{
   // An event object. 
   event e;

   // Create a task group and execute five tasks that wait for 
   // the event to be set.
   task_group tasks;
   for (int i = 0; i < 5; ++i)
   {
      tasks.run([&] {
         // Print a message before waiting on the event.
         wstringstream ss;
         ss << L"\t\tContext " << GetExecutionContextId() 
            << L": waiting on an event." << endl; 
         wcout << ss.str();

         // Wait for the event to be set.
         e.wait();

         // Print a message after the event is set.
         ss = wstringstream();
         ss << L"\t\tContext " << GetExecutionContextId() 
            << L": received the event." << endl; 
         wcout << ss.str();
      });
   }

   // Wait a sufficient amount of time for all tasks to enter  
   // the waiting state.
   Sleep(1000L);

   // Set the event.

   wstringstream ss;
   ss << L"\tSetting the event." << endl; 
   wcout << ss.str();

   e.set();

   // Wait for all tasks to complete.
   tasks.wait();
}

// Demonstrates the usage of preemptive events. 
void RunWindowsEvents()
{
   // A Windows event object.
   HANDLE hEvent = CreateEvent(NULL, TRUE, FALSE, TEXT("Windows Event"));

   // Create a task group and execute five tasks that wait for 
   // the event to be set.
   task_group tasks;
   for (int i = 0; i < 5; ++i)
   {
      tasks.run([&] {
         // Print a message before waiting on the event.
         wstringstream ss;
         ss << L"\t\tContext " << GetExecutionContextId() 
            << L": waiting on an event." << endl; 
         wcout << ss.str();

         // Wait for the event to be set.
         WaitForSingleObject(hEvent, INFINITE);

         // Print a message after the event is set.
         ss = wstringstream();
         ss << L"\t\tContext " << GetExecutionContextId() 
            << L": received the event." << endl; 
         wcout << ss.str();
      });
   }

   // Wait a sufficient amount of time for all tasks to enter  
   // the waiting state.
   Sleep(1000L);

   // Set the event.

   wstringstream ss;
   ss << L"\tSetting the event." << endl; 
   wcout << ss.str();

   SetEvent(hEvent);

   // Wait for all tasks to complete.
   tasks.wait();

   // Close the event handle.
   CloseHandle(hEvent);
}

int wmain()
{
   // Create a scheduler policy that allows up to two  
   // simultaneous tasks.
   SchedulerPolicy policy(1, MaxConcurrency, 2);

   // Attach the policy to the current scheduler.
   CurrentScheduler::Create(policy);

   wcout << L"Cooperative event:" << endl;
   RunCooperativeEvents();

   wcout << L"Windows event:" << endl;
   RunWindowsEvents();
}

Komentáře

Tento příklad vytvoří následující výstup:

Vzhledem k tomu, event třída chovat kooperativně, Plánovač zdroje můžete přerozdělit zpracování do jiného kontextu při událost čeká na signalizovaném stavu.Proto je dosaženo verze, která používá více práce event třídy.Ve verzi, která používá událostí systému Windows zadejte jednotlivé úkoly čekající signalizovaném stavu před zahájením dalšího úkolu.

Další informace o úkolech naleznete v části Funkční paralelismus (Concurrency Runtime).