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