Porównanie synchronizacji struktur danych do systemu Windows API

Artykuł
05/01/2013

W tym temacie porównuje zachowanie struktury danych synchronizacji, które są dostarczane przez Runtime współbieżności przez interfejs API systemu Windows.

Wykonaj struktur danych synchronizacji, które są dostarczane przez Runtime współbieżności model wątka współpracy.W modelu wątkowości współpracy synchronizacyjne plon wyraźnie ich przetwarzania zasobów innych wątków.To różni się od wywłaszczaniem model wątka, których zasoby przetwarzania są przenoszone do innych wątków przez harmonogram kontroli lub system operacyjny.

CRITICAL_SECTION

Concurrency::critical_section systemu Windows jest podobna do klasy CRITICAL_SECTION struktury, ponieważ mogą być używane tylko przez wątki jednego procesu.Aby uzyskać informacje dotyczące sekcji krytycznych w interfejsie API systemu Windows, zobacz Obiektów sekcji krytycznej.

reader_writer_lock

Concurrency::reader_writer_lock jest podobna do klasy blokad Czytnik/zapisywarka slim (SRW) systemu Windows.Poniższa tabela wyjaśnia podobieństw i różnic.

Funkcja	reader_writer_lock	Zablokuj SRW
Brak wywołał	Tak	Tak
Można podwyższyć czytnik Writer (obsługa uaktualnienia)	Nr	Nr
Można obniżyć writer czytnika (w dziale pomocy technicznej)	Nr	Nr
Blokada zapisu preferencji	Tak	Nr
FIFO dostępu do modułów zapisujących	Tak	Nr

Aby uzyskać więcej informacji na temat blokady SRW, zobacz blokad Czytnik/zapisywarka Slim (SRW) w zestawie SDK platformy.

Zdarzenie

Concurrency::event jest podobna do klasy nienazwanych, zdarzenie ręcznego wyzerowania systemu Windows.Jednakże event obiektu zachowuje się wspólnie, dlatego zdarzeń systemu Windows zachowuje się preemptively.Aby uzyskać więcej informacji dotyczących zdarzeń systemu Windows, zobacz Obiektów zdarzeń.

Przykład

Opis

Aby lepiej zrozumieć różnicę między event klasy i zdarzeń systemu Windows, należy rozważyć następujący przykład.Ten przykład włącza harmonogram utworzyć co najwyżej dwóch równoczesnych zadań, a następnie dwa podobne funkcje używające wywołania event klasy i zdarzenie ręcznego wyzerowania w systemie Windows.Każda funkcja najpierw tworzy kilka zadań, które oczekiwania dla zdarzenia udostępnionych zasygnalizowanie.Każda funkcja następnie plonów na zadania uruchomione, a następnie sygnalizuje zdarzenie.Każda funkcja czeka następnie zasygnalizowane zdarzenie.

Kod

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

Komentarze

Ten przykład generuje następujące przykładowe dane wyjściowe:

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.

Ponieważ event klasy zachowuje się wspólnie, harmonogramu można ponownie przydzielić zasoby przetwarzania kontekst, gdy zdarzenie oczekuje na przejście w stan zasygnalizowany.Dlatego więcej pracy jest realizowane przez wersji, która używa event klasy.W wersji, która używa zdarzeń systemu Windows każdego zadania oczekiwania należy wprowadzić stan zasygnalizowany, przed rozpoczęciem następnego zadania.

Aby uzyskać więcej informacji na temat zadań, zobacz Zadanie równoległości (współbieżności Runtime).