C ++ termina llamada sin una excepción activa

Estoy obteniendo un error de C ++ con subprocesamiento:

terminate called without an active exception Aborted 

Aquí está el código:

 #include  #include  #include  #include  template 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 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 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 buffer; std::mutex mtx; std::condition_variable stop_if_empty, stop_if_full; bool eof; }; 

Modelé mi código alrededor de este ejemplo: http://www.justsoftwaresolutions.co.uk/threading/implementing-a-thread-safe-queue-using-condition-variables.html

¿Qué estoy haciendo mal y cómo soluciono el error?

Cuando un objeto de subproceso queda fuera del scope y está en estado enlazable, el progtwig finaliza. El Comité Estándar tenía otras dos opciones para el destructor de un hilo que se puede unir. Podría unirse de forma silenciosa, pero unirse podría no volver nunca si el hilo está atascado. O podría separar el hilo (un hilo separado no se puede unir). Sin embargo, los hilos separados son muy difíciles, ya que podrían sobrevivir hasta el final del progtwig y arruinar la liberación de recursos. Por lo tanto, si no desea finalizar su progtwig, asegúrese de unirse (o desconectar) cada hilo.

Cómo reproducir ese error:

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

Comstackr y ejecutar:

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

Usted obtiene ese error porque no se unió o separó su hilo.

Una forma de solucionarlo, únete al hilo de esta manera:

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

Luego comstack y ejecuta:

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

La otra manera de arreglarlo, sepárelo así:

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

Comstackr y ejecutar:

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

Lea sobre la separación de subprocesos de C ++ y la unión de subprocesos de C ++.

Eric Leschinski y Bartosz Milewski ya dieron la respuesta. Aquí, trataré de presentarlo de una manera más amigable para principiantes.

Una vez que un subproceso se ha iniciado dentro de un ámbito (que se está ejecutando en un subproceso), se debe garantizar explícitamente que ocurra uno de los siguientes antes de que el subproceso quede fuera del scope:

  • El tiempo de ejecución sale del scope, solo después de que el hilo termina de ejecutarse. Esto se logra al unirse con ese hilo. Tenga en cuenta el idioma, es el scope externo que se une con ese hilo.
  • El tiempo de ejecución deja que el hilo se ejecute solo. Entonces, el progtwig saldrá del scope, ya sea que este subproceso termine de ejecutarse o no. Este hilo se ejecuta y sale solo. Esto se logra separando el hilo. Esto podría generar problemas, por ejemplo, si el hilo se refiere a variables en ese ámbito externo.

Tenga en cuenta que, en el momento en que el hilo se une o se separa, puede que se haya terminado de ejecutar. Aún así, cualquiera de las dos operaciones debe realizarse de forma explícita.