Comment les verrous de lecture/écriture en C peuvent-ils optimiser l'accès simultané pour les lecteurs fréquents et les écrivains peu fréquents ?

Verrous lecteur/écrivain en C : une solution efficace pour les lecteurs fréquents et les écrivains peu fréquents

En C, les verrous lecteur/écrivain sont un élément crucial primitive de synchronisation conçue pour optimiser l'accès simultané aux données partagées par plusieurs threads. Un cas d’utilisation qui bénéficie souvent des verrous lecteur/enregistreur est celui où il y a un seul écrivain peu fréquent et de nombreux lecteurs fréquents. Cet article explore l'approche C standard pour implémenter les verrous de lecture/écriture et une alternative utilisant Boost pour les anciennes versions du compilateur.

Solution C standard (C 14)

La solution préférée La solution multiplateforme dans les versions C modernes (depuis C 14 et VS2015) consiste à exploiter la bibliothèque en-tête. Cela fournit les types de verrous suivants :

• std::shared_mutex (alias Lock) : la classe de verrouillage de base
• std::unique_lock (alias WriteLock) : un verrou unique qui permet un accès exclusif en écriture aux données partagées
• std::shared_lock (alias ReadLock) : un verrou partagé qui permet un accès simultané en lecture aux données partagées

Solution Boost pour les anciennes versions

Pour les anciennes versions et normes du compilateur, une alternative robuste consiste à utiliser la bibliothèque de threads Boost. Boost fournit les types de verrouillage suivants :

• boost::shared_mutex (alias Lock) : la classe de verrouillage de base
• boost::unique_lock (alias WriteLock) : un verrou unique qui permet un accès exclusif en écriture aux données partagées
• boost::shared_lock (alias ReadLock) : un verrou partagé qui permet un accès simultané en lecture aux données partagées

Exemple d'utilisation

Voici comment utiliser à la fois le standard C et Boost solutions :

Standard C (C 14):

#include <shared_mutex>

typedef std::shared_mutex Lock;
typedef std::unique_lock< Lock > WriteLock;
typedef std::shared_lock< Lock > ReadLock;

Lock myLock;

void ReadFunction()
{
    ReadLock r_lock(myLock);
    // Do reader stuff
}

void WriteFunction()
{
    WriteLock w_lock(myLock);
    // Do writer stuff
}

Boost :

#include <boost/thread/locks.hpp>
#include <boost/thread/shared_mutex.hpp>

typedef boost::shared_mutex Lock;
typedef boost::unique_lock< Lock > WriteLock;
typedef boost::shared_lock< Lock > ReadLock;

Lock myLock;

void ReadFunction()
{
    ReadLock r_lock(myLock);
    // Do reader stuff
}

void WriteFunction()
{
    WriteLock w_lock(myLock);
    // Do writer stuff
}

En sélectionnant la solution appropriée en fonction de votre plateforme et de votre version C, vous pouvez gérer efficacement les partages ressources et optimisez les performances de vos applications simultanées où il y a beaucoup plus de lecteurs que d'écrivains.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!