Szinkronizálási adatstruktúrák összehasonlítása a Windows API-val

Ez a témakör az egyidejűségi futtatókörnyezet által biztosított szinkronizálási adatstruktúrák viselkedését hasonlítja össze a Windows API által biztosítottakkal.

Az egyidejűségi futtatókörnyezet által biztosított szinkronizálási adatstruktúrák a kooperatív szálmodellt követik. A kooperatív szálkezelési modellben a szinkronizálási primitívek explicit módon más szálakhoz adnak feldolgozási erőforrásokat. Ez eltér a megelőző szálmodelltől, ahol a feldolgozási erőforrásokat a vezérlő ütemező vagy az operációs rendszer más szálakra továbbítja.

kritikus szekció

Az concurrency::critical_section osztály hasonlít a Windows-struktúrához CRITICAL_SECTION, mert csak egy folyamat szálai használhatják. A Windows API kritikus szakaszaival kapcsolatos további információkért lásd: Kritikus szakaszobjektumok.

olvasó-író zár

A párhuzamosság::reader_writer_lock osztály hasonlít a Windows vékony olvasó-író (SRW) zárolására. Az alábbi táblázat a hasonlóságokat és a különbségeket ismerteti.

Tulajdonság	reader_writer_lock osztály	SRW-zárolás
Nem újrabeléphető	Igen	Igen
Előléptethet egy olvasót írónak (frissítési támogatás)	Nem	Nem
Átsorolhat egy írót olvasóvá (visszalépési támogatás)	Nem	Nem
Írási beállítások zárolása	Igen	Nem
FIFO-hozzáférés írókhoz	Igen	Nem

Az SRW-zárolásokról további információt a Platform SDK Slim Reader/Writer (SRW) zárolások részében találhat.

esemény

A concurrency::event osztály hasonlít egy névtelen, Windows kézi visszaállítású eseményre. Az event objektum azonban együttműködően viselkedik, míg egy Windows-esemény megelőző módon viselkedik. A Windows-eseményekről további információt az Event Objects (Eseményobjektumok) című témakörben talál.

példa

Leírás

Az osztály és a event Windows-események közötti különbség jobb megértéséhez tekintse meg az alábbi példát. Ez a példa lehetővé teszi, hogy az ütemező legfeljebb két egyidejű feladatot hozzon létre, majd meghívjon két hasonló függvényt, amelyek az event osztályt és a Windows manuális alaphelyzetbe állítási eseményét használják. Minden függvény először több olyan feladatot hoz létre, amely megvárja, amíg egy megosztott esemény jelzése létrejön. Az egyes függvények ezután átadják az irányítást a futó feladatoknak, majd értesítik az eseményt. Ezután minden függvény megvárja a jelzett eseményt.

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

Megjegyzések

Ez a példa a következő mintakimenetet hozza létre:

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.

Mivel az event osztály együttműködően viselkedik, az ütemező átcsoportosíthatja a feldolgozási erőforrásokat egy másik környezetbe, amikor egy esemény a jelzett állapot megadására vár. Ezért az osztályt használó event verzió több munkát végez. A Windows-eseményeket használó verzióban minden várakozási tevékenységnek a következő tevékenység megkezdése előtt meg kell adnia a jelzett állapotot.

A tevékenységekről további információt a feladat-párhuzamosság című témakörben talál.

Lásd még

Szinkronizálási adatstruktúrák