C ++ terminate wird ohne aktive Ausnahme aufgerufen

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?

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).

So reproduzieren Sie diesen Fehler:

#include <iostream>
#include <stdlib.h>
#include <string>
#include <thread>
using namespace std;
void task1(std::string msg){
  cout << "task1 says: " << msg;
}
int main() { 
  std::thread t1(task1, "hello"); 
  return 0;
}

Kompilieren und ausführen:

el@defiant ~/foo4/39_threading $ g++ -o s s.cpp -pthread -std=c++11
el@defiant ~/foo4/39_threading $ ./s
terminate called without an active exception
Aborted (core dumped)

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:

#include <iostream>
#include <stdlib.h>
#include <string>
#include <thread>
using namespace std;
void task1(std::string msg){
  cout << "task1 says: " << msg;
}
int main() { 
  std::thread t1(task1, "hello"); 
  t1.join();
  return 0;
}

Dann kompilieren und ausführen:

el@defiant ~/foo4/39_threading $ g++ -o s s.cpp -pthread -std=c++11
el@defiant ~/foo4/39_threading $ ./s
task1 says: hello

Die andere Möglichkeit, das Problem zu beheben, besteht darin, es wie folgt abzunehmen:

#include <iostream>
#include <stdlib.h>
#include <string>
#include <unistd.h>
#include <thread>
using namespace std;
void task1(std::string msg){
  cout << "task1 says: " << msg;
}
int main() 
{ 
     {

        std::thread t1(task1, "hello"); 
        t1.detach();

     } //thread handle is destroyed here, as goes out of scope!

     usleep(1000000); //wait so that hello can be printed.
}

Kompilieren und ausführen:

el@defiant ~/foo4/39_threading $ g++ -o s s.cpp -pthread -std=c++11
el@defiant ~/foo4/39_threading $ ./s
task1 says: hello

Informieren Sie sich über das Trennen von C ++ - Threads und das Verbinden von C ++ - Threads.

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:

• Die Laufzeit verlässt den Bereich erst, nachdem die Ausführung dieses Threads abgeschlossen ist. Dies wird durch Verbinden mit diesem Faden erreicht. Beachten Sie die Sprache, es ist der äußere Bereich, der sich mit diesem Thread verbindet.
• Die Laufzeit lässt den Thread alleine laufen. Das Programm verlässt also den Bereich, unabhängig davon, ob dieser Thread ausgeführt wurde oder nicht. Dieser Thread wird von selbst ausgeführt und beendet. Dies wird durch Abnehmen des Fadens erreicht. Dies kann beispielsweise zu Problemen führen, wenn der Thread auf Variablen in diesem äußeren Bereich verweist.

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.

Jahr muss der Thread join () sein. wenn der Hauptausgang

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.

int main(){

std::thread t(thread,1);

while(1){}

//t.detach();
return 0;}

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.

void thread(int n) {std::this_thread::sleep_for (std::chrono::seconds(n));}

int main() {
std::cout << "Start main\n";
std::thread t(thread,1);
std::thread t2(thread,3);
std::thread t3(thread,8);
sleep(5);

t.detach();
t2.detach();
t3.detach();
return 0;}

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.

Das implizite Trennen oder Verbinden eines joinable () - Threads in seinem Destruktor kann dazu führen, dass Fehler beim Debuggen der Korrektheit (zum Trennen) oder der Leistung (zum Verbinden) nur dann auftreten, wenn eine Ausnahme ausgelöst wird. Daher muss der Programmierer sicherstellen, dass der Destruktor niemals ausgeführt wird, solange der Thread noch verbunden werden kann.