활성 예외없이 호출 된 C ++ 종료

스레딩에 C ++ 오류가 발생합니다.

terminate called without an active exception
Aborted

다음은 코드입니다.

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

이 예제를 중심으로 코드를 모델링했습니다. http://www.justsoftwaresolutions.co.uk/threading/implementing-a-thread-safe-queue-using-condition-variables.html

내가 뭘 잘못하고 있고 어떻게 오류를 수정합니까?

스레드 개체가 범위를 벗어나 결합 가능한 상태가되면 프로그램이 종료됩니다. 표준위원회에는 조인 가능한 스레드의 소멸자에 대한 두 가지 다른 옵션이 있습니다. 조용히 조인 할 수 있지만 스레드가 멈춘 경우 조인이 반환되지 않을 수 있습니다. 또는 스레드를 분리 할 수 ​​있습니다 (분리 된 스레드는 결합 할 수 없음). 그러나 분리 된 스레드는 프로그램이 끝날 때까지 살아남아 리소스 해제를 망칠 수 있기 때문에 매우 까다 롭습니다. 따라서 프로그램을 종료하지 않으려면 모든 스레드를 조인 (또는 분리)해야합니다.

오류를 재현하는 방법 :

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

컴파일 및 실행 :

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)

스레드를 결합하거나 분리하지 않았기 때문에 해당 오류가 발생합니다.

이를 고치는 한 가지 방법은 다음과 같이 스레드를 결합하는 것입니다.

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

그런 다음 컴파일하고 실행합니다.

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

다른 방법은 다음과 같이 분리하는 것입니다.

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

컴파일 및 실행 :

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

C ++ 스레드 분리 및 C ++ 스레드 결합에 대해 읽어보십시오.

Eric Leschinski와 Bartosz Milewski는 이미 대답을했습니다. 여기서는 좀 더 초보자 친화적 인 방식으로 표현하려고 노력할 것입니다.

스레드가 범위 내에서 시작되면 (스레드에서 자체적으로 실행 됨) 스레드가 범위를 벗어나기 전에 다음 중 하나가 발생하는지 명시 적으로 확인해야합니다.

• 런타임은 스레드가 실행을 마친 후에 만 ​​범위를 종료합니다. 이것은 해당 스레드와 결합하여 달성됩니다. 언어에 유의하십시오. 해당 스레드와 결합하는 것은 외부 범위입니다.
• 런타임은 스레드가 자체적으로 실행되도록 둡니다. 따라서 프로그램은이 스레드가 실행을 완료했는지 여부에 관계없이 범위를 종료합니다. 이 스레드는 자체적으로 실행되고 종료됩니다. 이것은 스레드를 분리하여 수행됩니다. 예를 들어 스레드가 해당 외부 범위의 변수를 참조하는 경우 문제가 발생할 수 있습니다.

스레드가 결합되거나 분리 될 때까지 실행이 잘 완료되었을 수 있습니다. 여전히 두 작업 중 하나를 명시 적으로 수행해야합니다.

프로그램이 죽는 한 스레드를 분리하거나 결합하지 않으면이 오류가 발생합니다. 스레드를 분리하고 결합하지 않고 스레드를 생성 한 후 무한 루프를 제공해야합니다.

int main(){

std::thread t(thread,1);

while(1){}

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

잠자기 또는 루핑 후 스레드가 분리되거나 결합 될 수 있다는 것도 흥미 롭습니다. 또한 이렇게하면이 오류가 발생하지 않습니다.

아래 예제는 세 번째 스레드가 메인 다이 전에 자신의 작업을 수행 할 수 없음을 보여줍니다. 그러나이 오류는 코드의 어딘가에서 분리하는 한 발생할 수 없습니다. 세 번째 스레드는 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;}

year, 스레드는 join ()이어야합니다. 메인 출구

먼저 스레드를 정의합니다. 그리고 스레드 소멸자를 호출하기 전에 join () 또는 detach ()를 호출하지 않으면 프로그램이 중단됩니다.

다음과 같이 먼저 join (완료 될 때까지 기다리기 위해)을 호출하거나 분리하지 않고 스레드 소멸자를 호출하면 std :: terminate를 즉시 호출하고 프로그램을 종료 할 수 있습니다.

소멸자에서 joinable () 스레드를 암시 적으로 분리하거나 조인하면 예외가 발생할 때만 발생하는 정확성 (분리의 경우) 또는 성능 (조인의 경우) 버그를 디버그하기가 어려울 수 있습니다. 따라서 프로그래머는 스레드가 여전히 결합 가능한 동안 소멸자가 실행되지 않도록해야합니다.