C++ 终止在没有活动异常的情况下调用

C++ terminate called without an active exception

提问by 111111

I am getting a C++ error with threading:

我在线程中遇到 C++ 错误：

terminate called without an active exception
Aborted

Here is the 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;   
};

I modeled my code around this example: http://www.justsoftwaresolutions.co.uk/threading/implementing-a-thread-safe-queue-using-condition-variables.html

我围绕这个例子模拟了我的代码：http: //www.justsoftwaresolutions.co.uk/threading/implementing-a-thread-safe-queue-using-condition-variables.html

What am I doing wrong and how do I fix the error?

我做错了什么以及如何修复错误？

回答by Bartosz Milewski

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.

当线程对象超出范围并处于可连接状态时，程序将终止。对于可连接线程的析构函数，标准委员会还有另外两种选择。它可以悄悄地加入——但如果线程卡住，加入可能永远不会返回。或者它可以分离线程（分离的线程不可连接）。然而，分离的线程非常棘手，因为它们可能会一直存在到程序结束并破坏资源的释放。因此，如果您不想终止程序，请确保加入（或分离）每个线程。

回答by Eric Leschinski

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++11
el@defiant ~/foo4/39_threading $ ./s
terminate called without an active exception
Aborted (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++11
el@defiant ~/foo4/39_threading $ ./s
task1 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++11
el@defiant ~/foo4/39_threading $ ./s
task1 says: hello

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

阅读分离 C++ 线程和加入 C++ 线程。

回答by haripkannan

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

Eric Leschinski 和 Bartosz Milewski 已经给出了答案。在这里，我将尝试以对初学者更友好的方式呈现它。

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.

请注意，当线程加入或分离时，它可能已经完成执行。仍然必须显式执行这两个操作中的任何一个。

回答by user2908225

As long as your program die, then without detach or join of the thread, this error will occur. Without detaching and joining the thread, you should give endless loop after creating thread.

只要你的程序死掉，然后没有分离或加入线程，就会发生这个错误。在不分离和加入线程的情况下，您应该在创建线程后给出无限循环。

int main(){

std::thread t(thread,1);

while(1){}

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

It is also interesting that, after sleeping or looping, thread can be detach or join. Also with this way you do not get this error.

有趣的是，在休眠或循环之后，线程可以分离或加入。同样，通过这种方式，您不会收到此错误。

Below example also shows that, third thread can not done his job before main die. But this error can not happen also, as long as you detach somewhere in the code. Third thread sleep for 8 seconds but main will die in 5 seconds.

下面的例子也表明，第三个线程不能在主死之前完成他的工作。但是这个错误也不会发生，只要你在代码中的某个地方分离。第三个线程休眠 8 秒，但主线程将在 5 秒内死亡。

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

回答by yongyu wu

year, the thread must be join(). when the main exit

年，线程必须是 join()。当主出口