C ++ kết thúc được gọi mà không có ngoại lệ hoạt động

Tôi đang gặp lỗi C ++ với luồng:

terminate called without an active exception
Aborted

Đây là mã:

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

Tôi đã lập mô hình mã của mình xung quanh ví dụ này: http://www.justsoftwaresolutions.co.uk/threading/implecting-a-thread-safe-queue-using-condition-variables.html

Tôi đang làm gì sai và làm cách nào để sửa lỗi?

Khi một đối tượng luồng đi ra khỏi phạm vi và nó ở trạng thái có thể nối, chương trình sẽ bị kết thúc. Ủy ban Tiêu chuẩn có hai lựa chọn khác cho trình hủy của một chuỗi có thể kết hợp. Nó có thể lặng lẽ tham gia - nhưng tham gia có thể không bao giờ quay lại nếu chuỗi bị kẹt. Hoặc nó có thể tách chuỗi (một chuỗi tách ra không thể nối được). Tuy nhiên, các luồng tách rời rất phức tạp, vì chúng có thể tồn tại cho đến cuối chương trình và làm rối tung việc giải phóng tài nguyên. Vì vậy, nếu bạn không muốn chấm dứt chương trình của mình, hãy đảm bảo bạn tham gia (hoặc tách) mọi chuỗi.

Cách tạo lại lỗi đó:

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

Biên dịch và chạy:

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)

Bạn gặp lỗi đó vì bạn không tham gia hoặc tách chuỗi của mình.

Một cách để khắc phục nó, hãy tham gia chuỗi như thế này:

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

Sau đó biên dịch và chạy:

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

Cách khác để sửa nó, hãy tách nó ra như thế này:

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

Biên dịch và chạy:

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

Đọc thêm về tách các chuỗi C ++ và nối các chuỗi C ++.

Eric Leschinski và Bartosz Milewski đã đưa ra câu trả lời. Ở đây, tôi sẽ cố gắng trình bày nó một cách thân thiện hơn cho người mới bắt đầu.

Khi một tiểu trình đã được bắt đầu trong một phạm vi (chính nó đang chạy trên một tiểu trình), người ta phải đảm bảo một cách rõ ràng một trong những điều sau đây xảy ra trước khi tiểu trình đó ra khỏi phạm vi:

• Thời gian chạy thoát khỏi phạm vi, chỉ sau khi luồng đó kết thúc thực thi. Điều này đạt được bằng cách tham gia với chuỗi đó. Lưu ý ngôn ngữ, nó là phạm vi bên ngoài tham gia với luồng đó.
• Thời gian chạy để luồng tự chạy. Vì vậy, chương trình sẽ thoát khỏi phạm vi, cho dù luồng này đã thực thi xong hay chưa. Luồng này tự thực thi và thoát. Điều này đạt được bằng cách tách sợi. Điều này có thể dẫn đến các vấn đề, ví dụ, nếu chuỗi tham chiếu đến các biến trong phạm vi bên ngoài đó.

Lưu ý, vào thời điểm chuỗi được nối với hoặc tách ra, nó có thể đã hoàn tất quá trình thực thi. Vẫn phải thực hiện một trong hai thao tác một cách rõ ràng.

Miễn là chương trình của bạn chết, sau đó không tách hoặc nối chuỗi, lỗi này sẽ xảy ra. Không tách rời và nối chuỗi, bạn nên tạo vòng lặp vô tận sau khi tạo chuỗi.

int main(){

std::thread t(thread,1);

while(1){}

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

Điều thú vị là, sau khi ngủ hoặc lặp lại, luồng có thể được tách ra hoặc tham gia. Ngoài ra với cách này bạn không gặp lỗi này.

Ví dụ dưới đây cũng cho thấy rằng, luồng thứ ba không thể thực hiện công việc của mình trước khi main chết. Nhưng lỗi này cũng không thể xảy ra, miễn là bạn tách một nơi nào đó trong mã. Luồng thứ ba ngủ trong 8 giây nhưng chính sẽ chết sau 5 giây.

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

năm, chủ đề phải là join (). khi lối ra chính

Đầu tiên, bạn xác định một chủ đề. Và nếu bạn không bao giờ gọi tham gia () hoặc detach () trước khi gọi trình hủy luồng, chương trình sẽ hủy bỏ.

Như sau, việc gọi một trình hủy luồng mà không cần gọi tham gia trước (để đợi nó kết thúc) hoặc tách ra được yêu cầu ngay lập tức gọi std :: chấm dứt và kết thúc chương trình.

Việc tách hoặc tham gia ngầm một luồng có thể ghép nối () trong trình hủy của nó có thể dẫn đến việc khó gỡ lỗi về tính đúng đắn (đối với tách) hoặc lỗi hiệu suất (đối với tham gia) chỉ gặp phải khi một ngoại lệ được đưa ra. Do đó, người lập trình phải đảm bảo rằng hàm hủy không bao giờ được thực thi trong khi luồng vẫn có thể nối.