Wie können Lese-/Schreibsperren in C den gleichzeitigen Zugriff für häufige Leser und seltene Autoren optimieren?

Leser-/Schreibsperren in C: Eine effiziente Lösung für Vielleser und Wenigschreiber

In C sind Lese-/Schreibsperren von entscheidender Bedeutung Synchronisierungsprimitiv zur Optimierung des gleichzeitigen Zugriffs auf gemeinsam genutzte Daten durch mehrere Threads. Ein Anwendungsfall, der oft von Lese-/Schreibsperren profitiert, ist, wenn es einen einzelnen, seltenen Schreiber und viele häufige Lesegeräte gibt. Dieser Artikel untersucht den Standard-C-Ansatz zur Implementierung von Lese-/Schreibsperren und eine Alternative mit Boost für ältere Compilerversionen.

Standard-C-Lösung (C 14)

Die bevorzugte Eine plattformübergreifende Lösung in modernen C-Versionen (seit C 14 und VS2015) besteht darin, den der Standardbibliothek zu nutzen. Kopfzeile. Dies stellt die folgenden Sperrtypen bereit:

• std::shared_mutex (auch bekannt als Lock): Die Basissperrenklasse
• std::unique_lock (auch bekannt als WriteLock): Eine einzigartige Sperre, die exklusiven Schreibzugriff auf die freigegebenen Daten ermöglicht
• std::shared_lock (auch bekannt als ReadLock): Eine gemeinsame Sperre, die gleichzeitigen Lesezugriff auf die freigegebenen Daten ermöglicht

Boost-Lösung für ältere Versionen

Für ältere Compilerversionen und -standards: Eine robuste Alternative ist die Verwendung der Boost-Threading-Bibliothek. Boost bietet die folgenden Sperrtypen:

• boost::shared_mutex (auch bekannt als Lock): Die Basissperrklasse
• boost::unique_lock (auch bekannt als WriteLock): Eine einzigartige Sperre, die exklusiven Schreibzugriff auf die freigegebenen Daten ermöglicht
• boost::shared_lock (auch bekannt als ReadLock): Eine gemeinsame Sperre, die gleichzeitigen Lesezugriff auf die freigegebenen Daten ermöglicht

Beispielverwendung

Hier erfahren Sie, wie Sie sowohl Standard C als auch Boost verwenden Lösungen:

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
}

Durch Auswahl der geeigneten Lösung basierend auf Ihrer Plattform und C-Version können Sie Shared effizient verwalten Ressourcen und optimieren Sie die Leistung für Ihre gleichzeitigen Anwendungen, bei denen es viel mehr Leser als Autoren gibt.

Das obige ist der detaillierte Inhalt vonWie können Lese-/Schreibsperren in C den gleichzeitigen Zugriff für häufige Leser und seltene Autoren optimieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!