Ich erhalte einen C ++ - Fehler beim Threading:
terminate called without an active exception
Aborted
Hier ist der Code:
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
template<typename TYPE>
class blocking_stream
{
public:
blocking_stream(size_t max_buffer_size_)
: max_buffer_size(max_buffer_size_)
{
}
//PUSH data into the buffer
blocking_stream &operator<<(TYPE &other)
{
std::unique_lock<std::mutex> mtx_lock(mtx);
while(buffer.size()>=max_buffer_size)
stop_if_full.wait(mtx_lock);
buffer.push(std::move(other));
mtx_lock.unlock();
stop_if_empty.notify_one();
return *this;
}
//POP data out of the buffer
blocking_stream &operator>>(TYPE &other)
{
std::unique_lock<std::mutex> mtx_lock(mtx);
while(buffer.empty())
stop_if_empty.wait(mtx_lock);
other.swap(buffer.front());
buffer.pop();
mtx_lock.unlock();
stop_if_full.notify_one();
return *this;
}
private:
size_t max_buffer_size;
std::queue<TYPE> buffer;
std::mutex mtx;
std::condition_variable stop_if_empty,
stop_if_full;
bool eof;
};
Ich habe meinen Code anhand dieses Beispiels modelliert: http://www.justsoftwaresolutions.co.uk/threading/implementing-a-thread-safe-queue-using-condition-variables.html
Was mache ich falsch und wie behebe ich den Fehler?
c++
multithreading
deadlock
c++11
111111
quelle
quelle
join
alle Ihre Threads in Ihrem Hauptprogramm?Antworten:
Wenn ein Thread-Objekt den Gültigkeitsbereich verlässt und sich im verbindbaren Zustand befindet, wird das Programm beendet. Das Standardkomitee hatte zwei weitere Optionen für den Destruktor eines verbindbaren Threads. Es könnte leise beitreten - aber beitreten könnte niemals zurückkehren, wenn der Thread stecken bleibt. Oder es könnte den Thread lösen (ein losgelöster Thread kann nicht verbunden werden). Abgelöste Threads sind jedoch sehr schwierig, da sie bis zum Ende des Programms überleben und die Freigabe von Ressourcen durcheinander bringen können. Wenn Sie Ihr Programm also nicht beenden möchten, stellen Sie sicher, dass Sie jedem Thread beitreten (oder ihn trennen).
quelle
std::async
? Wie können Sie einen dort erstellten Thread verbinden / trennen? Es scheint nicht genug zu sein, auf die resultierende Zukunft zu warten, da dies besagt, dass der Thread "möglicherweise aus einem Thread-Pool stammen könnte" und das wait () der Zukunft nicht wirklich bedeutet, einen Thread in einem Pool zu beenden (und das würde nicht) sowieso keinen Sinn für vernünftige Thread-Pools).std::jthread
nennt.join()
in dem destructor (wie es Spielraum erlischt). Was mir persönlich besser gefällt, da es RAII besser folgt.So reproduzieren Sie diesen Fehler:
Kompilieren und ausführen:
Sie erhalten diesen Fehler, weil Sie Ihren Thread nicht verbunden oder getrennt haben.
Eine Möglichkeit, dies zu beheben, besteht darin, den Thread wie folgt zu verbinden:
Dann kompilieren und ausführen:
Die andere Möglichkeit, das Problem zu beheben, besteht darin, es wie folgt abzunehmen:
Kompilieren und ausführen:
Informieren Sie sich über das Trennen von C ++ - Threads und das Verbinden von C ++ - Threads.
quelle
Eric Leschinski und Bartosz Milewski haben die Antwort bereits gegeben. Hier werde ich versuchen, es anfängerfreundlicher darzustellen.
Sobald ein Thread innerhalb eines Bereichs gestartet wurde (der selbst auf einem Thread ausgeführt wird), muss explizit sichergestellt werden, dass eine der folgenden Aktionen ausgeführt wird, bevor der Thread den Bereich verlässt:
Beachten Sie, dass die Ausführung des Threads zu dem Zeitpunkt, zu dem er verbunden oder getrennt wird, möglicherweise vollständig abgeschlossen ist. Dennoch muss eine der beiden Operationen explizit ausgeführt werden.
quelle
Jahr muss der Thread join () sein. wenn der Hauptausgang
quelle
Solange Ihr Programm stirbt und der Thread nicht getrennt oder verbunden wird, tritt dieser Fehler auf. Ohne den Thread zu lösen und zu verbinden, sollten Sie nach dem Erstellen des Threads eine Endlosschleife geben.
Es ist auch interessant, dass sich der Faden nach dem Schlafen oder Schleifen lösen oder verbinden kann. Auch auf diese Weise erhalten Sie diesen Fehler nicht.
Das folgende Beispiel zeigt auch, dass der dritte Thread seine Arbeit nicht vor dem Hauptwürfel erledigen kann. Dieser Fehler kann aber auch nicht auftreten, solange Sie sich irgendwo im Code trennen. Der dritte Thread schläft 8 Sekunden lang, aber der Haupt-Thread stirbt in 5 Sekunden.
quelle
Zuerst definieren Sie einen Thread. Und wenn Sie niemals join () oder attach () aufrufen, bevor Sie den Thread-Destruktor aufrufen, wird das Programm abgebrochen.
Wenn Sie einen Thread-Destruktor aufrufen, ohne zuerst join aufzurufen (um zu warten, bis er beendet ist) oder trennen, wird garantiert, dass std :: terminate sofort aufgerufen und das Programm beendet wird.
quelle