Kapan saya harus menggunakan std :: thread :: detach?

Kadang-kadang saya harus menggunakan std::threaduntuk mempercepat aplikasi saya. Saya juga tahu join()menunggu sampai utas selesai. Ini mudah dimengerti, tetapi apa perbedaan antara menelepon detach()dan tidak menelepon?

Saya pikir tanpa detach(), metode utas akan bekerja menggunakan utas secara mandiri.

Tidak melepaskan:

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

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

    //some code here
}

Memanggil dengan melepaskan:

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

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

    t.detach();

    //some code here
}

Di destruktor dari std::thread, std::terminatedipanggil jika:

• utas tidak bergabung (dengan t.join())
• dan juga tidak terlepas (dengan t.detach())

Jadi, Anda harus selalu salah satu joinatau detachutas sebelum aliran eksekusi mencapai destruktor.

Ketika sebuah program berhenti (mis., mainMengembalikan) sisa utas yang terlepas yang dieksekusi di latar belakang tidak menunggu; sebagai gantinya, eksekusinya ditangguhkan dan objek lokal thread mereka dihancurkan.

Yang terpenting, ini berarti bahwa tumpukan utas tersebut tidak dibatalkan dan dengan demikian beberapa perusak tidak dieksekusi. Bergantung pada tindakan yang seharusnya dilakukan oleh para destruktor tersebut, ini mungkin situasi yang seburuk jika program telah rusak atau telah terbunuh. Mudah-mudahan OS akan melepaskan kunci pada file, dll ... tetapi Anda bisa merusak memori bersama, file setengah tertulis, dan sejenisnya.

Jadi, haruskah Anda menggunakan joinatau detach?

• Menggunakan join
• Kecuali jika Anda perlu memiliki lebih banyak fleksibilitas DAN bersedia memberikan mekanisme sinkronisasi untuk menunggu penyelesaian utas sendiri , dalam hal ini Anda dapat menggunakandetach

Anda harus memanggil detachjika Anda tidak akan menunggu utas selesai jointetapi utas akan terus berjalan sampai selesai dan kemudian menghentikannya tanpa harus menunggu utas utama secara khusus.

detachpada dasarnya akan mengeluarkan sumber daya yang dibutuhkan untuk dapat mengimplementasikan join.

Ini adalah kesalahan fatal jika objek utas mengakhiri hidupnya dan tidak joinjuga tidak detachdipanggil; dalam hal terminateini dipanggil.

Jika Anda melepaskan utas, artinya Anda tidak perlu melepaskannya join()sebelum keluar main().

Perpustakaan utas sebenarnya akan menunggu setiap utas seperti itu di bawah-utama , tetapi Anda tidak perlu peduli tentang itu.

detach()berguna terutama saat Anda memiliki tugas yang harus diselesaikan di latar belakang, tetapi Anda tidak peduli dengan pelaksanaannya. Ini biasanya terjadi pada beberapa perpustakaan. Mereka mungkin secara diam-diam membuat thread pekerja latar belakang dan melepaskannya sehingga Anda tidak akan menyadarinya.

Jawaban ini ditujukan untuk menjawab pertanyaan di judul, daripada menjelaskan perbedaan antara joindan detach. Jadi kapan sebaiknya std::thread::detachdigunakan?

Dalam kode C ++ yang dipelihara dengan baik std::thread::detachtidak boleh digunakan sama sekali. Programmer harus memastikan bahwa semua utas yang dibuat keluar dengan anggun dan melepaskan semua sumber daya yang diperoleh dan melakukan tindakan pembersihan lain yang diperlukan. Ini menyiratkan bahwa menyerahkan kepemilikan utas dengan meminta detachbukanlah suatu pilihan dan oleh karena itu joinharus digunakan dalam semua skenario.

Namun beberapa aplikasi bergantung pada API lama dan seringkali tidak dirancang dengan baik dan didukung yang mungkin berisi fungsi pemblokiran tanpa batas. Memindahkan pemanggilan fungsi ini ke utas khusus untuk menghindari pemblokiran hal-hal lain adalah praktik umum. Tidak ada cara untuk membuat utas seperti itu keluar dengan anggun sehingga penggunaan joinhanya akan mengarah ke pemblokiran utas utama. Itu adalah situasi ketika menggunakan detachakan menjadi alternatif yang kurang jahat, katakanlah, mengalokasikan threadobjek dengan durasi penyimpanan dinamis dan kemudian dengan sengaja membocorkannya.

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

Menurut cppreference.com :

Memisahkan utas eksekusi dari objek utas, memungkinkan eksekusi berlanjut secara independen. Sumber daya apa pun yang dialokasikan akan dibebaskan setelah utas keluar.

Setelah memanggil detach *thistidak lagi memiliki utas apa pun.

Sebagai contoh:

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

Perhatikan variabel lokal:, my_threadsementara masa pakai my_threadberakhir, destruktor dari std::threadakan dipanggil, dan std::terminate()akan dipanggil di dalam destruktor.

Tetapi jika Anda menggunakan detach(), Anda tidak boleh menggunakan my_threadlagi, bahkan jika masa pakai my_threadsudah berakhir, tidak ada yang akan terjadi pada utas baru.