C++ terminate called without an active exception

When a thread object goes out of scope and it is in joinable state, the program is terminated. The Standard Committee had two other options for the destructor of a joinable thread. It could quietly join -- but join might never return if the thread is stuck. Or it could detach the thread (a detached thread is not joinable). However, detached threads are very tricky, since they might survive till the end of the program and mess up the release of resources. So if you don't want to terminate your program, make sure you join (or detach) every thread.

How to reproduce that error:

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

Compile and run:

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

You get that error because you didn't join or detach your thread.

One way to fix it, join the thread like this:

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

Then compile and run:

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

The other way to fix it, detach it like this:

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

Compile and run:

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

Read up on detaching C++ threads and joining C++ threads.

Eric Leschinski and Bartosz Milewski have given the answer already. Here, I will try to present it in a more beginner friendly manner.

Once a thread has been started within a scope (which itself is running on a thread), one must explicitly ensure one of the following happens before the thread goes out of scope:

• The runtime exits the scope, only after that thread finishes executing. This is achieved by joining with that thread. Note the language, it is the outer scope that joins with that thread.
• The runtime leaves the thread to run on its own. So, the program will exit the scope, whether this thread finished executing or not. This thread executes and exits by itself. This is achieved by detaching the thread. This could lead to issues, for example, if the thread refers to variables in that outer scope.

Note, by the time the thread is joined with or detached, it may have well finished executing. Still either of the two operations must be performed explicitly.