Erstellen einer Warteschlange Blockiert

Manchmal ist diese Umsetzung und Durchführung von BlockingQueue funktioniert einfach. Manchmal ist es segfaults. Irgendeine Idee warum?

#include <thread>
using std::thread;
#include <mutex>
using std::mutex;
#include <iostream>
using std::cout;
using std::endl;
#include <queue>
using std::queue;
#include <string>
using std::string;
using std::to_string;
#include <functional>
using std::ref;

template <typename T>
class BlockingQueue {
private:
    mutex mutex_;
    queue<T> queue_;
public:
    T pop() {
        this->mutex_.lock();
        T value = this->queue_.front();
        this->queue_.pop();
        this->mutex_.unlock();
        return value;
    }

    void push(T value) {
        this->mutex_.lock();
        this->queue_.push(value);
        this->mutex_.unlock();
    }

    bool empty() {
        this->mutex_.lock();
        bool check = this->queue_.empty();
        this->mutex_.unlock();
        return check;
    }
};

void fillWorkQueue(BlockingQueue<string>& workQueue) {
    int size = 40000;
    for(int i = 0; i < size; i++)
        workQueue.push(to_string(i));
}

void doWork(BlockingQueue<string>& workQueue) {
    while(!workQueue.empty()) {
        workQueue.pop();
    }   
}

void multiThreaded() {
    BlockingQueue<string> workQueue;
    fillWorkQueue(workQueue);
    thread t1(doWork, ref(workQueue));
    thread t2(doWork, ref(workQueue));
    t1.join();
    t2.join();
    cout << "done\n";
}

int main() {
    cout << endl;

    //Multi Threaded
    cout << "multiThreaded\n";
    multiThreaded();
    cout << endl;
}

Wenn es segfaults, ich nehme an, du könntest die Zeile code wo ist es passiert? Könnte nur hilfreich sein, zu wissen...
Was passiert, wenn Sie überprüfen, ob die itemQueue leer ist, dann lassen Sie andere thread einige Arbeit, und dann pop() ein item???
Diese Frage hat genug code, jeder kann es ausprobieren und selbst sehen, wo das problem ist. Gibt es nicht viel überflüssigen code, so dass es nicht weit Weg ein lehrbuch SSCCE und sicherlich zu vertreten hat.
Ich habe eine harte Zeit zu glauben, dass "Wo ist der Fehler in diesem Programm?" jemals sein könnte ist eine gute Frage.
Gerne erklären mein denken auf diese eine weitere auf meta oder im chat, wenn Sie möchten, aber lassen Sie uns das bitte vermeiden Sie Chats in den Kommentaren.

InformationsquelleAutor Chris Redford | 2014-05-14

blockingqueue c++c++11 multithreading

3

Siehe hier:

Was bekomme ich von der Vorderseite () - leer-std-container?

Schlimme Dinge passieren, wenn Sie anrufen .front() auf einen leeren container, besser überprüfen .empty() ersten.

Versuchen:
```
T pop() {
    this->mutex_.lock();
    T value;
    if( !this->queue_.empty() )
    {
        value = this->queue_.front();  //undefined behavior if queue_ is empty
                                       //may segfault, may throw, etc.
        this->queue_.pop();
    }
    this->mutex_.unlock();
    return value;
}
```
Hinweis: Da Atomare Operationen sind wichtig, auf diese Art von Schlange, würde ich empfehlen, API-änderungen:
```
bool pop(T &t);  //returns false if there was nothing to read.
```
Besser noch, wenn man eigentlich mit, wo es darauf ankommt, werden Sie wahrscheinlich wollen, um Einträge zu markieren, im Einsatz vor dem löschen im Falle des Scheiterns.
```
bool peekAndMark(T &t);  //allows one "marked" item per thread
void deleteMarked();     //if an item is marked correctly, pops it.
void unmark();           //abandons the mark. (rollback)
```
- Tatsächlich habe ich gerade meiden std:: - und C++ selbst. Weit eher mit C++/CLI, C#, C, Java, eigentlich alles außer Vanille C++ und STL. Jede Sprache definieren Ausnahme, wie eine unsichere misfeature verdient eine miss in meinem Buch. Ich meine, wer implementiert eine leere Warteschlange Lesen als segfault?!
- Zur Umsetzung Lock/Unlock-Sequenzen auf diese Weise in c++ ist fehleranfällig (und möglicherweise auch in anderen Sprachen), da es nicht exception-safe. Sie können entweder einen der std:lock_guard Redewendungen zur Verfügung gestellt von der c++ - standard, oder Rollen Sie Sie, wenn nötig leicht!
- Ich bin damit einverstanden, auf die API ändern. Es ist eine gute Lösung zur Vermeidung der "was zu verwenden als der default-Wert" problem.
- Sollte man normalerweise nicht so direkt! Verwenden Sie einen geeigneten Gültigkeitsbereich Konstruktion/Zerstörung idiom statt!
- Okay @πάνταῥεῖ. Ich bin damit einverstanden, dass die Verwendung unique_lock<mutex> lock(this->mutex_) Ergebnisse in lesbarer code.
- Sorry, langsam zu sein, ich hatte, um darüber nachzudenken ein bisschen. Sie scheinen Attribut diese 2 Zeilen code für mich einfach, da hielt ich Sie in meiner Antwort. Ich, sehr deutlich, kopieren-einfügen, Sie von der Frage. Ein bisschen wie ein Außenseiter zu C++ war es für mich ganz klar das Missverständnis darüber, wie .front() funktioniert. Also entschied ich mich für highlight Fallstricke, die ich bin vertraut mit. Ich weiß wirklich nicht genug über lock_guard zu kommentieren. Also werde ich nicht. Wirklich, mit std::string die einzige Ausnahme, die möglich ist, aus dem Speicher. Das sollte wohl tödlich sein in den meisten einfachen Programme sowieso.
InformationsquelleAutor
4

Sollte das problem lag hier:
```
while(!itemQueue.empty()) {
    itemQueue.pop();
}
```
Behalten Sie den mutex, wenn die überprüfung ein Wert übrig ist, lassen Sie dann den mutex und es kann passieren, dass ein anderer thread ausgeführt wird, findet heraus, dass ein Wert übrig ist, und es erscheint. Im schlimmsten Fall, dass kein Element übrig ist, und danach den ersten thread versucht zu pop während kein element mehr übrig ist.

Die Lösung ist die front - /pop-Anrufe auf der internen Warteschlange in der gleichen Abschnitt als die Kontrolle für die leere in der gleiche gesperrte Abschnitt, dann das Verhalten wäre immer definiert werden.

Ein weiterer Vorschlag wäre, die Nutzung std::lock_guard bei der Arbeit mit mutex, weil es verbessert die Lesbarkeit und stellt sicher, dass der mutex wird freigegeben, egal was passiert.

In Anbetracht der Tatsache, diese zwei Ratschläge, Ihre pop Methode könnte wie folgt Aussehen:
```
T pop() {
    std::lock_guard lock(this->mutex_); //mutex_ is locked
    T value;
    if( !this->queue_.empty() )
    {
        value = this->queue_.front();
        this->queue_.pop();
    }
    return value;
} //mutex_ is freed
```
- +1 ich erwähne Nur eine standard-oder benutzerdefinierte auto locker Mechanismus, und Ihre Antwort sollte perfekt sein, wenn die niedrige Qualität der Frage!
- Und was passiert, wenn itemQueue leer ist? segfault, oder die Ausnahme, oder nicht definiertes Verhalten. Ich glaube, die std::queue.front() Verhalten ist die überraschung hier nicht, dass threads, die Vorrang vor jedem anderen. Wenn Sie hatten erwähnt es explizit, ich würde nicht die Mühe mit einer Antwort.
- Ich spreche über die pop Methode, die er implementiert.
- Wert; im Ernst? Wie es scheint, Sie kopieren-einfügen mein code.
- meinst du std::lock_guard<std::mutex> lock(this->mutex_);?
- hängt von der mutex-Typ Sie verwenden.
InformationsquelleAutor Theolodis

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.