Win32 Lecture/Écriture De Verrouillage En Utilisant Uniquement Les Sections Critiques

Je ne pense pas que cela peut être fait sans l'aide d'au moins un noyau d'objet de niveau (Mutex ou Sémaphore), parce que vous avez besoin de l'aide du noyau de rendre le processus appelant bloc jusqu'à ce que le verrou est disponible.

Sections critiques fournissent de blocage, mais l'API est trop limitée. par exemple, vous ne pouvez pas saisir un CS, de découvrir qu'un verrou de lecture est disponible, mais pas un verrou en écriture, et d'attendre pour les autres processus de finir la lecture (parce que si les autres processus de la section critique, il permet de bloquer les autres lecteurs, ce qui est faux, et si ce n'est pas alors votre processus se bloque pas mais le spin, la gravure de cycles CPU.)

Cependant, ce que vous pouvez faire est d'utiliser un verrou de rotation et de revenir à un mutex lorsqu'il y a conflit. La section critique est elle-même mise en œuvre de cette façon. Je voudrais prendre un existant de la section critique de la mise en œuvre et de remplacer le champ PID avec lecteur séparé & écrivain qui compte.

OriginalL'auteur finnw

Vieille question, mais c'est quelque chose qui devrait fonctionner. Elle ne tourne pas sur la contention. Les lecteurs engager limitée des frais supplémentaires s'ils ont peu ou pas de conflit, car SetEvent est appelé paresseusement (regardez l'historique d'édition pour une version poids lourd qui n'ont pas cette optimisation).

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

Vous pouvez diminuer le coût pour les lecteurs en utilisant un seul CRITICAL_SECTION:

• countsLock est remplacé par writerLock dans rdlock et rdunlock

• rwlock->waitingWriter = FALSE est retiré dans wrunlock

• wrlock du corps est changé à

  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.  */

Cependant ce perd dans l'équité, donc je préfère la solution ci-dessus.

OriginalL'auteur Paolo Bonzini

Découvrez la spin_rw_mutex de Intel Fil De Blocs De Construction ...

spin_rw_mutex est strictement dans l'espace utilisateur
et emploie spin-attendre que le blocage

OriginalL'auteur JP Alioto

Si vous savez déjà d'une solution qui seulement utilise les mutex, vous devriez être en mesure de le modifier pour utiliser les sections critiques à la place.

Nous avons lancé notre propre aide de deux sections critiques et des compteurs. Ce qui correspond à nos besoins, nous avons une très faible écrivain comte, écrivains obtenir la priorité sur les lecteurs, etc. Je n'ai pas la liberté de publier la nôtre mais qui peut dire qu'il est possible sans les mutex et les sémaphores.

OriginalL'auteur sean e

Regarder ma mise en œuvre ici:

https://github.com/coolsoftware/LockLib

VRWLock est une classe C++ qui implémente seul écrivain de plusieurs lecteurs logiques.

Aussi regarder projet de test TestLock.la sln.

UPD. Ci-dessous est le code simple pour le lecteur et l'écrivain:

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 classe prend en charge nombre de rotations et de thread spécifique de comptage de référence qui permet de libérer les verrous de résiliation threads.

OriginalL'auteur Vitaly