Khi nào tôi nên sử dụng std :: thread :: detach?

Đôi khi tôi phải sử dụng std::threadđể tăng tốc ứng dụng của mình. Tôi cũng biết join()chờ đợi cho đến khi một chủ đề hoàn thành. Điều này là dễ hiểu, nhưng sự khác biệt giữa gọi detach()và không gọi nó là gì?

Tôi nghĩ rằng không có detach(), phương thức của luồng sẽ hoạt động bằng cách sử dụng một luồng độc lập.

Không tách ra:

void Someclass::Somefunction() {
    //...

    std::thread t([ ] {
        printf("thread called without detach");
    });

    //some code here
}

Gọi với tách ra:

void Someclass::Somefunction() {
    //...

    std::thread t([ ] {
        printf("thread called with detach");
    });

    t.detach();

    //some code here
}

Trong hàm hủy của std::thread, std::terminateđược gọi nếu:

• chủ đề không được tham gia (với t.join())
• và không bị tách ra (với t.detach())

Vì vậy, bạn phải luôn luôn joinhoặc detachmột luồng trước khi các luồng thực thi đến hàm hủy.

Khi một chương trình kết thúc (tức là maintrả về), các luồng tách rời còn lại đang thực thi trong nền không được chờ đợi; thay vào đó, việc thực thi của chúng bị đình chỉ và các đối tượng luồng cục bộ của chúng bị phá hủy.

Điều quan trọng, điều này có nghĩa là ngăn xếp của các luồng đó không phải là không có và do đó một số hàm hủy không được thực thi. Tùy thuộc vào các hành động mà những kẻ hủy diệt đáng lẽ phải thực hiện, đây có thể là một tình huống tồi tệ như thể chương trình đã bị hỏng hoặc đã bị giết. Hy vọng rằng HĐH sẽ giải phóng các khóa trên các tệp, v.v ... nhưng bạn có thể đã làm hỏng bộ nhớ dùng chung, các tệp được ghi một nửa và tương tự.

Vậy, bạn nên sử dụng joinhay detach?

• Sử dụng join
• Trừ khi bạn cần phải có sự linh hoạt hơn và sẵn sàng cung cấp một cơ chế đồng bộ để chờ đợi để hoàn đề trên của riêng bạn , trong trường hợp này bạn có thể sử dụngdetach

Bạn nên gọi detachnếu bạn sẽ không đợi luồng hoàn thành joinnhưng luồng thay vào đó sẽ tiếp tục chạy cho đến khi hoàn thành và sau đó chấm dứt mà không có luồng chính chờ cụ thể.

detachvề cơ bản sẽ giải phóng các tài nguyên cần thiết để có thể thực hiện join.

Đó là một lỗi nghiêm trọng nếu một đối tượng luồng kết thúc vòng đời của nó và joincũng không detachđược gọi; trong trường hợp terminatenày được gọi

Khi bạn tách chủ đề, điều đó có nghĩa là bạn không phải thực hiện join()trước khi thoát main().

Thư viện luồng thực sự sẽ chờ từng luồng như vậy bên dưới chính , nhưng bạn không nên quan tâm đến nó.

detach()chủ yếu hữu ích khi bạn có một nhiệm vụ phải hoàn thành trong nền, nhưng bạn không quan tâm đến việc thực hiện nó. Đây thường là một trường hợp cho một số thư viện. Họ có thể âm thầm tạo ra một luồng công nhân nền và tách nó ra để bạn thậm chí không nhận thấy nó.

Câu trả lời này nhằm mục đích trả lời câu hỏi trong tiêu đề, thay vì giải thích sự khác biệt giữa joinvà detach. Vậy khi nào nên std::thread::detachdùng?

Trong mã C ++ được duy trì đúng cách hoàn toàn std::thread::detachkhông nên được sử dụng. Lập trình viên phải đảm bảo rằng tất cả các luồng được tạo ra thoát một cách duyên dáng sẽ giải phóng tất cả các tài nguyên có được và thực hiện các hành động dọn dẹp cần thiết khác. Điều này ngụ ý rằng việc từ bỏ quyền sở hữu các luồng bằng cách gọi detachkhông phải là một tùy chọn và do đó joinnên được sử dụng trong tất cả các kịch bản.

Tuy nhiên, một số ứng dụng dựa trên các API cũ và thường không được thiết kế và hỗ trợ có thể chứa các chức năng chặn vô thời hạn. Di chuyển các hàm của các hàm này thành một luồng chuyên dụng để tránh chặn các thứ khác là một cách làm phổ biến. Không có cách nào để tạo ra một luồng như vậy để thoát một cách duyên dáng vì vậy việc sử dụng joinsẽ chỉ dẫn đến chặn luồng chính. Đó là một tình huống khi sử dụng detachsẽ là một sự thay thế ít tệ hại hơn, giả sử, phân bổ threadđối tượng với thời gian lưu trữ động và sau đó cố tình rò rỉ nó.

#include <LegacyApi.hpp>
#include <thread>

auto LegacyApiThreadEntry(void)
{
    auto result{NastyBlockingFunction()};
    // do something...
}

int main()
{
    ::std::thread legacy_api_thread{&LegacyApiThreadEntry};
    // do something...
    legacy_api_thread.detach();
    return 0;
}

Theo cppreference.com :

Tách luồng thực thi khỏi đối tượng luồng, cho phép thực thi tiếp tục độc lập. Bất kỳ tài nguyên được phân bổ sẽ được giải phóng khi luồng thoát.

Sau khi gọi tách ra *thiskhông còn sở hữu bất kỳ chủ đề.

Ví dụ:

  std::thread my_thread([&](){XXXX});
  my_thread.detach();

Lưu ý biến cục bộ : my_thread, trong khi thời gian tồn tại my_threadkết thúc, hàm hủy của std::threadsẽ được gọi và std::terminate()sẽ được gọi trong hàm hủy.

Nhưng nếu bạn sử dụng detach(), bạn không nên sử dụng my_threadnữa, ngay cả khi thời gian my_threadkết thúc, sẽ không có gì xảy ra với luồng mới.