Verrous lecteur/enregistreur minces (SRW)

Les verrous lecteur/writer (SRW) minces permettent aux threads d’un processus unique d’accéder aux ressources partagées ; ils sont optimisés pour la vitesse et occupent très peu de mémoire. Les verrous de l’enregistreur de lecteurs minces ne peuvent pas être partagés entre les processus.

Les threads de lecture lisent les données d’une ressource partagée, tandis que les threads d’écriture écrivent des données dans une ressource partagée. Lorsque plusieurs threads lisent et écrivent à l’aide d’une ressource partagée, des verrous exclusifs tels qu’une section critique ou un mutex peuvent devenir un goulot d’étranglement si les threads de lecture s’exécutent en continu, mais les opérations d’écriture sont rares.

Les verrous SRW fournissent deux modes dans lesquels les threads peuvent accéder à une ressource partagée :

• mode partagé, qui accorde un accès en lecture seule partagé à plusieurs threads de lecture, ce qui leur permet de lire des données à partir de la ressource partagée simultanément. Si les opérations de lecture dépassent les opérations d’écriture, cette concurrence augmente les performances et le débit par rapport aux sections critiques.

  Note

  Les verrous SRW en mode partagé ne doivent pas être acquis de manière récursive, car cela peut entraîner des interblocages lorsqu’ils sont combinés à une acquisition exclusive.

• mode exclusif, qui accorde un accès en lecture/écriture à un thread d’écriture à la fois. Lorsque le verrou a été acquis en mode exclusif, aucun autre thread ne peut accéder à la ressource partagée tant que l’enregistreur n’a pas libéré le verrou.

  Note

  Les verrous SRW en mode exclusif ne peuvent pas être acquis de manière récursive. Si un thread tente d’acquérir un verrou qu’il contient déjà, cette tentative échoue (pour TryAcquireSRWLockExclusive) ou interblocage (pour AcquireSRWLockExclusive)

Un seul verrou SRW peut être acquis en mode ou en mode ; Les threads de lecteur peuvent l’acquérir en mode partagé, tandis que les threads d’écriture peuvent l’acquérir en mode exclusif. Il n’existe aucune garantie sur l’ordre dans lequel les threads qui demandent la propriété seront accordés ; Les verrous SRW ne sont ni équitables ni FIFO.

Un verrou SRW est la taille d’un pointeur. L’avantage est qu’il est rapide de mettre à jour l’état du verrou. L’inconvénient est que très peu d’informations d’état peuvent être stockées, de sorte que les verrous SRW ne détectent pas une utilisation récursive incorrecte en mode partagé. En outre, un thread propriétaire d’un verrou SRW en mode partagé ne peut pas mettre à niveau sa propriété du verrou en mode exclusif.

L’appelant doit allouer une structure SRWLOCK et l’initialiser en appelant InitializeSRWLock (pour initialiser la structure dynamiquement) ou affecter la constante SRWLOCK_INIT à la variable de structure (pour initialiser la structure statiquement).

Vous pouvez utiliser vérificateur d’application pour rechercher l’utilisation récursive (réentrant) des verrous SRW.

Voici les fonctions de verrouillage SRW.

Fonction de verrouillage SRW	Description
AcquireSRWLockExclusive	Acquiert un verrou SRW en mode exclusif.
AcquireSRWLockShared	Acquiert un verrou SRW en mode partagé.
InitializeSRWLock	Initialisez un verrou SRW.
ReleaseSRWLockExclusive	Libère un verrou SRW ouvert en mode exclusif.
releaseSRWLockShared	Libère un verrou SRW ouvert en mode partagé.
sleepConditionVariableSRW	Veille sur la variable de condition spécifiée et libère le verrou spécifié en tant qu’opération atomique.
TryAcquireSRWLockExclusive	Tente d’acquérir un verrou de lecteur/enregistreur (SRW) mince en mode exclusif. Si l’appel réussit, le thread appelant prend possession du verrou.
TryAcquireSRWLockShared	Tente d’acquérir un verrou de lecteur/enregistreur (SRW) mince en mode partagé. Si l’appel réussit, le thread appelant prend possession du verrou.