Когда я должен использовать std :: thread :: detach?

Иногда я должен использовать std::threadдля ускорения моего приложения. Я также знаю, join()ждет, пока поток не завершится. Это легко понять, но в чем разница между звонком detach()и не звонком?

Я думал, что без detach(), метод потока будет работать с использованием потока независимо.

Не отрываясь:

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

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

    //some code here
}

Звонок с отрывом:

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

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

    t.detach();

    //some code here
}

В деструкторе std::thread, std::terminateназывается, если:

• нить не была присоединена (с t.join())
• и не был отделен либо (с t.detach())

Таким образом, вы должны всегда joinили detachпоток, прежде чем потоки выполнения достигнут деструктора.

Когда программа завершает работу (т.е. mainвозвращает), остальные ожидающие потоки, выполняющиеся в фоновом режиме, не ожидаются; вместо этого их выполнение приостанавливается и их локальные объекты потока разрушаются.

Важно, что это означает, что стек этих потоков не разматывается, и поэтому некоторые деструкторы не выполняются. В зависимости от действий, которые должны были предпринять эти деструкторы, ситуация может быть такой же плохой, как если бы программа потерпела крах или была убита. Надеюсь, ОС снимет блокировки файлов и т. Д., Но вы могли повредить общую память, наполовину записанные файлы и т.п.

Итак, вы должны использовать joinили detach?

• использование join
• Если вам не нужно иметь больше гибкости и готовы предоставить механизм синхронизации , чтобы ждать завершения потока по своему усмотрению , в этом случае вы можете использоватьdetach

Вы должны вызывать, detachесли вы не собираетесь ждать завершения потока, joinно вместо этого поток просто продолжит работать до тех пор, пока он не будет завершен, а затем завершит работу, не ожидая, что основной поток ожидает его специально.

detachв основном высвободит ресурсы, необходимые для реализации join.

Это фатальная ошибка , если объект потока не завершает свою жизнь и ни joinни detachбыл назван; в этом случае terminateвызывается.

Когда вы отсоединяете нить, это означает, что вы не должны делать join()это перед выходом main().

Библиотека потоков на самом деле будет ждать каждого такого потока ниже основной , но вы не должны заботиться об этом.

detach()в основном полезно, когда у вас есть задача, которая должна быть выполнена в фоновом режиме, но вы не заботитесь о ее выполнении. Это обычно относится к некоторым библиотекам. Они могут молча создать фоновый рабочий поток и отключить его, чтобы вы даже не заметили этого.

Этот ответ направлен на ответ на вопрос в названии, а не на объяснение разницы между joinи detach. Итак, когда следует std::thread::detachиспользовать?

В должным образом поддерживаемом коде C ++ std::thread::detachне следует использовать вообще. Программист должен убедиться, что все созданные потоки корректно завершаются, высвобождая все полученные ресурсы и выполняя другие необходимые действия по очистке. Это подразумевает, что отказ от владения потоками путем вызова detachне является вариантом и, следовательно, joinдолжен использоваться во всех сценариях.

Однако некоторые приложения полагаются на старые и часто не очень хорошо разработанные и поддерживаемые API, которые могут содержать бесконечно блокирующие функции. Перемещение вызовов этих функций в отдельный поток, чтобы избежать блокировки других вещей, является обычной практикой. Невозможно изящно joinзавершить такой поток, поэтому его использование приведет лишь к блокировке основного потока. Это ситуация, когда использование detachбыло бы менее злой альтернативой, скажем, выделению threadобъекта с динамической длительностью хранения, а затем преднамеренной утечке.

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

По данным cppreference.com :

Отделяет поток выполнения от объекта потока, позволяя продолжить выполнение независимо. Любые выделенные ресурсы будут освобождены после выхода из потока.

После вызова detach *thisбольше не владеет ни одной веткой.

Например:

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

Обратите внимание на локальную переменную: my_threadкогда время жизни my_threadистекло, std::threadбудет вызываться деструктор и std::terminate()внутри деструктора.

Но если вы используете detach(), вы не должны использовать my_threadбольше, даже если время жизни my_threadистекло, с новым потоком ничего не произойдет.