Quando devo usar std :: thread :: desanexar?

Em algum momento eu tenho que usar std::threadpara acelerar meu aplicativo. Eu também sei join()espera até que um segmento seja concluído. Isso é fácil de entender, mas qual é a diferença entre ligar detach()e não ligar?

Eu pensei que detach(), sem , o método do thread funcionará usando um thread de forma independente.

Não desanexando:

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

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

    //some code here
}

Ligando com desanexação:

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

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

    t.detach();

    //some code here
}

No destruidor de std::thread, std::terminateé chamado se:

• o encadeamento não foi unido (com t.join())
• e também não foi desanexado (com t.detach())

Portanto, você sempre deve ter um joinou detachum encadeamento antes que os fluxos de execução cheguem ao destruidor.

Quando um programa termina (ou seja, mainretorna), os demais segmentos desanexados em execução em segundo plano não são esperados; em vez disso, sua execução é suspensa e seus objetos locais de thread destruídos.

Fundamentalmente, isso significa que a pilha desses threads não é desenrolada e, portanto, alguns destruidores não são executados. Dependendo das ações que esses destruidores deveriam empreender, essa poderia ser uma situação tão ruim como se o programa tivesse travado ou tivesse sido morto. Esperamos que o sistema operacional libere os bloqueios nos arquivos, etc ... mas você pode ter corrompido a memória compartilhada, os arquivos semi-escritos e similares.

Então, você deve usar joinou detach?

• Usar join
• A menos que você precise ter mais flexibilidade E esteja disposto a fornecer um mecanismo de sincronização para aguardar a conclusão do encadeamento por conta própria , nesse caso, você poderá usardetach

Você deve ligar detachse não quiser esperar que o encadeamento seja concluído, joinmas o encadeamento continuará sendo executado até que esteja pronto e será encerrado sem que o encadeamento principal o aguarde especificamente.

detachbasicamente liberará os recursos necessários para poder implementar join.

É um erro fatal se um objeto de encadeamento termina sua vida e nem joinnem detachfoi chamado; neste caso terminateé invocado.

Quando você desanexa o encadeamento, significa que você não precisa fazer join()isso antes de sair main().

A biblioteca de encadeamentos realmente aguardará cada um desses encadeamentos abaixo do principal , mas você não deve se preocupar com isso.

detach()é útil principalmente quando você tem uma tarefa que precisa ser executada em segundo plano, mas não se importa com a execução. Geralmente, esse é o caso de algumas bibliotecas. Eles podem criar silenciosamente um thread de trabalho em segundo plano e desanexá-lo para que você nem perceba.

Esta resposta visa responder à pergunta no título, em vez de explicar a diferença entre joine detach. Então, quando deve std::thread::detachser usado?

No código C ++ mantido adequadamente std::thread::detach, não deve ser usado. O programador deve garantir que todos os threads criados saiam normalmente, liberando todos os recursos adquiridos e executando outras ações de limpeza necessárias. Isso implica que renunciar à propriedade dos encadeamentos invocando detachnão é uma opção e, portanto, joindeve ser usado em todos os cenários.

No entanto, alguns aplicativos contam com APIs antigas e muitas vezes mal projetadas e suportadas, que podem conter funções de bloqueio indefinidamente. Mover invocações dessas funções para um thread dedicado para evitar o bloqueio de outras coisas é uma prática comum. Não há como fazer com que esse encadeamento saia normalmente, portanto, o uso de joinapenas levará ao bloqueio do encadeamento primário. Essa é uma situação em que o uso detachseria uma alternativa menos ruim para, por exemplo, alocar um threadobjeto com duração de armazenamento dinâmico e vazá-lo de propósito.

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

De acordo com cppreference.com :

Separa o encadeamento de execução do objeto de encadeamento, permitindo que a execução continue independentemente. Quaisquer recursos alocados serão liberados assim que o encadeamento terminar.

Após chamar desanexar, *thisnão possui mais nenhum segmento.

Por exemplo:

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

Observe a variável local: my_threadenquanto o tempo de vida útil my_threadterminar, o destruidor de std::threadserá chamado e std::terminate()será chamado dentro do destruidor.

Mas se você usar detach(), não deverá my_threadmais usá-lo , mesmo que a vida útil my_threadtenha acabado, nada acontecerá com o novo encadeamento.