Beispiel für boost shared_mutex (mehrere Lesevorgänge/ein Schreibvorgang)?

Question 1

Ich habe eine Multithread-App, die einige Daten häufig lesen muss, und gelegentlich werden diese Daten aktualisiert. Im Moment hält ein Mutex den Zugriff auf diese Daten sicher, aber es ist teuer, weil ich möchte, dass mehrere Threads gleichzeitig lesen können und sie nur sperren, wenn ein Update erforderlich ist (der Aktualisierungsthread könnte warten, bis die anderen Threads fertig sind). .

Ich denke, das ist was boost::shared_mutex soll tun, aber ich bin mir nicht sicher, wie ich es verwenden soll, und habe kein klares Beispiel gefunden.

Hat jemand ein einfaches Beispiel, mit dem ich anfangen könnte?

Question 2

1800 INFORMATION ist mehr oder weniger korrekt, aber es gibt ein paar Probleme, die ich korrigieren wollte.

boost::shared_mutex _access;
void reader()
{
  boost::shared_lock< boost::shared_mutex > lock(_access);
  // do work here, without anyone having exclusive access
}

void conditional_writer()
{
  boost::upgrade_lock< boost::shared_mutex > lock(_access);
  // do work here, without anyone having exclusive access

  if (something) {
    boost::upgrade_to_unique_lock< boost::shared_mutex > uniqueLock(lock);
    // do work here, but now you have exclusive access
  }

  // do more work here, without anyone having exclusive access
}

void unconditional_writer()
{
  boost::unique_lock< boost::shared_mutex > lock(_access);
  // do work here, with exclusive access
}

Beachten Sie auch, dass im Gegensatz zu einem shared_lock nur ein einzelner Thread gleichzeitig ein upgrade_lock erwerben kann, selbst wenn es nicht aktualisiert wird (was ich als unangenehm empfand, als ich darauf stieß). Wenn also alle Ihre Leser bedingte Schreiber sind, müssen Sie eine andere Lösung finden.

Question 3

Es sieht so aus, als würdest du so etwas tun:

boost::shared_mutex _access;
void reader()
{
  // get shared access
  boost::shared_lock<boost::shared_mutex> lock(_access);

  // now we have shared access
}

void writer()
{
  // get upgradable access
  boost::upgrade_lock<boost::shared_mutex> lock(_access);

  // get exclusive access
  boost::upgrade_to_unique_lock<boost::shared_mutex> uniqueLock(lock);
  // now we have exclusive access
}

Question 4

Seit C++ 17 (VS2015) können Sie den Standard für Lese-Schreib-Sperren verwenden:

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

Für ältere Versionen können Sie boost mit derselben Syntax verwenden:

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

Question 5

Verwenden Sie ein Semaphor mit einer Anzahl, die gleich der Anzahl der Leser ist. Lassen Sie jeden Leser die Semaphore einmal zählen, um zu lesen, damit alle gleichzeitig lesen können. Lassen Sie dann den Schreiber vor dem Schreiben ALLE Semaphor-Zählungen vornehmen. Dies führt dazu, dass der Writer wartet, bis alle Lesevorgänge abgeschlossen sind, und dann Lesevorgänge während des Schreibens blockiert.

Question 6

Tolle Antwort von Jim Morris, ich bin darüber gestolpert und es hat eine Weile gedauert, bis ich es herausgefunden habe. Hier ist ein einfacher Code, der zeigt, dass nach dem Absenden einer “Anfrage” für einen Unique_lock-Boost (Version 1.54) alle Shared_lock-Anfragen blockiert werden. Dies ist sehr interessant, da es mir scheint, dass die Wahl zwischen unique_lock und upgradeable_lock erlaubt, ob wir Schreibpriorität oder keine Priorität wollen.

Auch (1) in Jim Morris’ Beitrag scheint dem zu widersprechen: Boost shared_lock. Bevorzugt lesen?

#include <iostream>
#include <boost/thread.hpp>

using namespace std;

typedef boost::shared_mutex Lock;
typedef boost::unique_lock< Lock > UniqueLock;
typedef boost::shared_lock< Lock > SharedLock;

Lock tempLock;

void main2() {
    cout << "10" << endl;
    UniqueLock lock2(tempLock); // (2) queue for a unique lock
    cout << "11" << endl;
    boost::this_thread::sleep(boost::posix_time::seconds(1));
    lock2.unlock();
}

void main() {
    cout << "1" << endl;
    SharedLock lock1(tempLock); // (1) aquire a shared lock
    cout << "2" << endl;
    boost::thread tempThread(main2);
    cout << "3" << endl;
    boost::this_thread::sleep(boost::posix_time::seconds(3));
    cout << "4" << endl;
    SharedLock lock3(tempLock); // (3) try getting antoher shared lock, deadlock here
    cout << "5" << endl;
    lock1.unlock();
    lock3.unlock();
}