Porovnání struktury synchronizace dat a rozhraní API systému Windows

Článek
05/01/2013

Toto téma porovnává chování synchronizace datových struktur, poskytovaných Runtime souběžnosti těm, které poskytuje rozhraní API systému Windows.

Synchronizace struktury dat, poskytovaných Runtime souběžnosti postupujte spolupráce model podprocesu.Spolupráce model podprocesu v primitivní synchronizace explicitně výnos své prostředky zpracování jiných podprocesů.Tím se liší preemptivní model podprocesu, kde převedeny prostředky jiných podprocesů Plánovač řízení nebo operačního systému.

critical_section

Concurrency::critical_section Windows se podobá třídě CRITICAL_SECTION struktury, protože jej lze používat pouze podprocesy jednoho procesu.Další informace o kritických oddílů v rozhraní API systému Windows naleznete v Důležité části objekty.

reader_writer_lock

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

Funkce	reader_writer_lock	Zámek SRW
Které nejsou přístupné.	Ano	Ano
Může podporovat reader Writer (podpora upgradu)	Ne	Ne
Můžete snížit úroveň Zapisovatel pro čtenáře (downgrade podpora)	Ne	Ne
Zápis předvoleb zámku	Ano	Ne
FIFO přístup pro zápis	Ano	Ne

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

Událost

Concurrency::event třídy podobná událost bez názvu, ruční obnovení systému Windows.Však event objektu chová ve vzhledem k tomu, že se chová preemptively událostí systému Windows.Další informace o událostech systému Windows naleznete v tématu Objekty událostí.

Příklad

Description

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ě dvou současných úkolů 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é čekat sdílené událostí se stanou signalizováno následným tichem.Každá funkce pak dává spuštěných úkolů a potom signály události.Každá funkce 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:

Cooperative event:
                Context 0: waiting on an event.
                Context 1: waiting on an event.
                Context 2: waiting on an event.
                Context 3: waiting on an event.
                Context 4: waiting on an event.
        Setting the event.
                Context 5: received the event.
                Context 6: received the event.
                Context 7: received the event.
                Context 8: received the event.
                Context 9: received the event.
Windows event:
                Context 10: waiting on an event.
                Context 11: waiting on an event.
        Setting the event.
                Context 12: received the event.
                Context 14: waiting on an event.
                Context 15: received the event.
                Context 16: waiting on an event.
                Context 17: received the event.
                Context 18: waiting on an event.
                Context 19: received the event.
                Context 13: received the event.

Protože event se chová ve třídě, Plánovač zdroje můžete přerozdělit zpracování kontextu při události čeká na signalizovaném stavu.Proto je dosaženo další pracovní verzi, která používá event třídy.Ve verzi, která používá událostí systému Windows musí každý úkol čekání zadejte signalizovaném stavu před zahájením dalšího úkolu.

Další informace o úlohách naleznete v Úkol rovnoběžnosti (souběžnosti Runtime).