Win32-Lese/Schreib-Sperre Mit Nur Kritische Abschnitte

Ich glaube nicht, dass dies getan werden kann, ohne mindestens eine kernel-level-Objekt (Mutex oder Semaphore), denn Sie brauchen die Hilfe der kernel zu machen der aufrufende Prozess blockiert, bis die Sperre verfügbar ist.

Kritische Abschnitte bieten blockieren, aber die API ist auch begrenzt. z.B. können Sie nicht schnappen Sie sich einen CS, entdecken Sie, dass ein read-lock vorhanden ist, aber nicht eine Schreibsperre, und warten Sie, bis der andere Prozess zu Ende Lesen (weil wenn der andere Prozess den kritischen Abschnitt blockiert andere Leser, die falsch ist, und wenn nicht dann ist dein Prozess wird nicht blockiert, sondern spin, burning CPU-Zyklen.)

Jedoch, was Sie tun kann, ist ein spin lock-und wieder zurückgehen, um einen mutex, wenn es Konflikte. Der kritische Abschnitt selbst implementiert diese Weise. Ich würde einen vorhandenen kritischen Abschnitt-Implementierung und ersetzen Sie das PID-Feld mit separaten reader & Schriftsteller zählt.

Alte Frage, aber das ist etwas, das sollte funktionieren. Es spielt keine spin auf den Streit. Leser entstehen, beschränkt sich zusätzliche Kosten, wenn Sie wenig oder kein Streit, weil SetEvent genannt wird träge (schauen Sie sich die Bearbeitungs-history für eine komplexere version, die nicht über diese Optimierung).

#include <windows.h>

typedef struct _RW_LOCK {
    CRITICAL_SECTION countsLock;
    CRITICAL_SECTION writerLock;
    HANDLE noReaders;
    int readerCount;
    BOOL waitingWriter;
} RW_LOCK, *PRW_LOCK;

void rwlock_init(PRW_LOCK rwlock)
{
    InitializeCriticalSection(&rwlock->writerLock);
    InitializeCriticalSection(&rwlock->countsLock);

    /*
     * Could use a semaphore as well.  There can only be one waiter ever,
     * so I'm showing an auto-reset event here.
     */
    rwlock->noReaders = CreateEvent (NULL, FALSE, FALSE, NULL);
}

void rwlock_rdlock(PRW_LOCK rwlock)
{
    /*
     * We need to lock the writerLock too, otherwise a writer could
     * do the whole of rwlock_wrlock after the readerCount changed
     * from 0 to 1, but before the event was reset.
     */
    EnterCriticalSection(&rwlock->writerLock);
    EnterCriticalSection(&rwlock->countsLock);
    ++rwlock->readerCount;
    LeaveCriticalSection(&rwlock->countsLock);
    LeaveCriticalSection(&rwlock->writerLock);
}

int rwlock_wrlock(PRW_LOCK rwlock)
{
    EnterCriticalSection(&rwlock->writerLock);
    /*
     * readerCount cannot become non-zero within the writerLock CS,
     * but it can become zero...
     */
    if (rwlock->readerCount > 0) {
        EnterCriticalSection(&rwlock->countsLock);

        /* ... so test it again.  */
        if (rwlock->readerCount > 0) {
            rwlock->waitingWriter = TRUE;
            LeaveCriticalSection(&rwlock->countsLock);
            WaitForSingleObject(rwlock->noReaders, INFINITE);
        } else {
            /* How lucky, no need to wait.  */
            LeaveCriticalSection(&rwlock->countsLock);
        }
    }

    /* writerLock remains locked.  */
}

void rwlock_rdunlock(PRW_LOCK rwlock)
{
    EnterCriticalSection(&rwlock->countsLock);
    assert (rwlock->readerCount > 0);
    if (--rwlock->readerCount == 0) {
        if (rwlock->waitingWriter) {
            /*
             * Clear waitingWriter here to avoid taking countsLock
             * again in wrlock.
             */
            rwlock->waitingWriter = FALSE;
            SetEvent(rwlock->noReaders);
        }
    }
    LeaveCriticalSection(&rwlock->countsLock);
}

void rwlock_wrunlock(PRW_LOCK rwlock)
{
    LeaveCriticalSection(&rwlock->writerLock);
}

Könnten Sie verringert die Kosten für die Leserinnen und Leser durch die Verwendung einer einzigen CRITICAL_SECTION:

• countsLock ersetzt mit writerLock im rdlock und rdunlock

• rwlock->waitingWriter = FALSE entfernt in wrunlock

• wrlock Körper geändert wird, um

  EnterCriticalSection(&rwlock->writerLock);
  rwlock->waitingWriter = TRUE;
  while (rwlock->readerCount > 0) {
      LeaveCriticalSection(&rwlock->writerLock);
      WaitForSingleObject(rwlock->noReaders, INFINITE);
      EnterCriticalSection(&rwlock->writerLock);
  }
  rwlock->waitingWriter = FALSE;
  
  /* writerLock remains locked.  */

Doch diese verliert in der fairness, so dass ich lieber die oben genannte Lösung.

Check-out die spin_rw_mutex von Intel Thread Building Blocks ...

spin_rw_mutex ist streng im user-land
und beschäftigt spin-warten Sie, bis die Blockierung

Wenn Sie bereits wissen, von einer Lösung, die nur Mutexe verwendet, sollten Sie in der Lage sein, diese zu ändern, um die Verwendung von kritischen Abschnitten statt.

Rollten wir unsere eigenen mit zwei kritischen Abschnitten und einige Schalter. Es passt unsere Bedürfnisse, wir haben eine sehr niedrige Schriftsteller Graf, Schriftsteller erhalten Vorrang vor Lesern, etc. Ich bin nicht die Freiheit, zu veröffentlichen, uns aber sagen können, dass es möglich ist, ohne Mutexe und Semaphoren.

Schaut meine Umsetzung hier:

https://github.com/coolsoftware/LockLib

VRWLock ist eine C++ - Klasse implementiert, single writer - mehrere Leser-Logik.

Suchen Sie auch test-Projekt TestLock.sln.

UPD. Unten ist der einfache code für reader-und writer:

LONG gCounter = 0;

//reader

for (;;) //loop
{
  LONG n = InterlockedIncrement(&gCounter); 
  //n = value of gCounter after increment
  if (n <= MAX_READERS) break; //writer does not write anything - we can read
  InterlockedDecrement(&gCounter);
}
//read data here
InterlockedDecrement(&gCounter); //release reader

//writer

for (;;) //loop
{
  LONG n = InterlockedCompareExchange(&gCounter, (MAX_READERS+1), 0); 
  //n = value of gCounter before attempt to replace it by MAX_READERS+1 in InterlockedCompareExchange
  //if gCounter was 0 - no readers/writers and in gCounter will be MAX_READERS+1
  //if gCounter was not 0 - gCounter stays unchanged
  if (n == 0) break;
}
//write data here
InterlockedExchangeAdd(&gCounter, -(MAX_READERS+1)); //release writer

VRWLock Klasse unterstützt spin-Zählung und thread-spezifische Referenz-Zählung erlaubt Freigabe der sperren von threads beendet.