Wäre eine solche Klasse nur einmal durch mehrere Threads lesbar?

Question

mit So eine Klasse wie:

class mySafeData 
{ 
public: 
    mySafeData() : myData(0), changed(false) 
    { 
    } 

    void Set(int i) 
    { 
    boost::mutex::scoped_lock lock(myMutex); 
    myData = i; // set the data 
    changed = true; // mark as changed 
    myCondvar.notify_one(); // notify so a reader can process it 
    } 

    void Get(int& i) 
    { 
    boost::mutex::scoped_lock lock(myMutex); 
    while(!changed) 
    { 
     myCondvar.wait(lock); 
    } 
    i = myData; 
    changed = false; // mark as read 
    myCondvar.notify_one(); // notify so the writer can write if necessary 
    } 
private: 
    int myData; 
    boost::mutex myMutex; 
    boost::condition_variable myCondvar; 
    bool changed; 
}; 

Und ein Thread in Schleife Set aufrufen. Und 3 oder mehr Threads Aufruf Get wie alle Threads aufrufen Get machen, um tatsächlich Daten zu erhalten (jeder Thread soll Get Daten nur einmal Set wurde aufgerufen) (es scheint nur der erste "Leser" wer ruft Get ruft Daten)?

Update wird dies tun ?:

class mySafeData 
{ 
public: 
    mySafeData() : myData(0) 
    { 
    } 

    void Set(int i) 
    { 
    boost::mutex::scoped_lock lock(myMutex); 
    myData = i; // set the data 
    } 

    void Get(int& i) 
    { 
    boost::mutex::scoped_lock lock(myMutex); 
    i = myData; 

    } 
private: 
    int myData; 
    boost::mutex myMutex; 
}; 

Answer 1

Eigentlich ist es ein seltsamer Ansatz, notify_one() im Leser (Get) aufzurufen! Wenn Sie Ihre Leser wollen warten, bis etwas gesetzt wurde, dann müssen Sie etwas wie folgt aus:

void Set(int i) 
    { 
    boost::mutex::scoped_lock lock(myMutex); 
    myData = i; // set the data 
    ++stateCounter; // some int to track state chages 
    myCondvar.notify_all(); // notify all readers 
    } 

    void Get(int& i) 
    { 
    boost::mutex::scoped_lock lock(myMutex); 
    // copy the current state 
    int cState = stateCounter; 
    // waits for a notification and change of state 
    while (stateCounter == cState) 
     myCondvar.wait(lock); 
    } 

Jetzt ein Aufruf an Get effektiv warten, bis es eine gültige Zustandsänderung ist. Dieser Ansatz (mit Bedingungen) ist jedoch anfällig für Probleme wie falsche Wakeups (die von der Schleife behandelt werden sollten), verlorene Benachrichtigungen usw. Sie müssen ein besseres Modell dafür finden (alles klingt wie ein Fall einer Warteschlange pro Thread)).

Answer 2

Ich glaube nicht, dass Sie die Bedingung Variable benötigen; der Mutex sollte genug sein.

Auch die changed Variable hilft Ihnen nicht; Es erlaubt nur einem Thread, die Änderung zu sehen. Entferne das auch.