Quand dois-je utiliser std :: thread :: detach?

Parfois, je dois utiliser std::threadpour accélérer mon application. Je sais aussi qu'il join()attend la fin d'un fil. C'est facile à comprendre, mais quelle est la différence entre appeler detach()et ne pas l'appeler?

Je pensais que sans detach(), la méthode du thread fonctionnera en utilisant un thread indépendamment.

Ne pas se détacher:

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

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

    //some code here
}

Appel avec détachement:

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

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

    t.detach();

    //some code here
}

Dans le destructeur de std::thread, std::terminateest appelé si:

• le fil n'a pas été joint (avec t.join())
• et n'était pas détaché non plus (avec t.detach())

Ainsi, vous devez toujours soit joinou detachun thread avant que les flux d'exécution n'atteignent le destructeur.

Lorsqu'un programme se termine (c'est-à-dire qu'il mainretourne), les threads détachés restants s'exécutant en arrière-plan ne sont pas attendus; au lieu de cela, leur exécution est suspendue et leurs objets locaux de thread détruits.

Fondamentalement, cela signifie que la pile de ces threads n'est pas déroulée et que certains destructeurs ne sont donc pas exécutés. Selon les actions que ces destructeurs étaient censés entreprendre, cela pourrait être une situation aussi grave que si le programme s'était écrasé ou avait été tué. Espérons que le système d'exploitation libérera les verrous sur les fichiers, etc., mais vous pourriez avoir corrompu la mémoire partagée, les fichiers à moitié écrits, etc.

Alors, devriez-vous utiliser joinou detach?

• Utilisation join
• À moins que vous n'ayez besoin de plus de flexibilité ET que vous soyez prêt à fournir un mécanisme de synchronisation pour attendre la fin du thread par vous-même , auquel cas vous pouvez utiliserdetach

Vous devriez appeler detachsi vous n'attendez pas que le thread se termine, joinmais le thread continuera à fonctionner jusqu'à ce que ce soit terminé, puis se terminera sans que le thread principal l'attende spécifiquement.

detachva essentiellement libérer les ressources nécessaires pour être en mesure de mettre en œuvre join.

C'est une erreur fatale si un objet thread termine sa vie et que ni joinni detachn'a été appelé; dans ce cas terminateest invoquée.

Lorsque vous détachez le fil, cela signifie que vous n'êtes pas obligé de le join()faire avant de quitter main().

La bibliothèque de threads attendra chaque thread ci-dessous , mais vous ne devriez pas vous en soucier.

detach()est principalement utile lorsque vous avez une tâche qui doit être effectuée en arrière-plan, mais que vous ne vous souciez pas de son exécution. C'est généralement le cas pour certaines bibliothèques. Ils peuvent créer silencieusement un thread de travail en arrière-plan et le détacher afin que vous ne le remarquiez même pas.

Cette réponse vise à répondre à la question dans le titre, plutôt qu'à expliquer la différence entre joinet detach. Alors, quand faut- std::thread::detachil l'utiliser?

Dans le code C ++ correctement entretenu, std::thread::detachne doit pas du tout être utilisé. Le programmeur doit s'assurer que tous les threads créés se terminent correctement en libérant toutes les ressources acquises et en exécutant les autres actions de nettoyage nécessaires. Cela implique que renoncer à la propriété des threads en appelant detachn'est pas une option et joindoit donc être utilisé dans tous les scénarios.

Cependant, certaines applications reposent sur des API anciennes et souvent mal conçues et prises en charge qui peuvent contenir des fonctions de blocage indéfiniment. Déplacer les invocations de ces fonctions dans un thread dédié pour éviter de bloquer d'autres éléments est une pratique courante. Il n'y a aucun moyen de faire en sorte qu'un tel thread se termine correctement, donc l'utilisation de joinmènera simplement au blocage du thread principal. C'est une situation dans laquelle l'utilisation detachserait une alternative moins mauvaise, par exemple, à l'allocation d'un threadobjet avec une durée de stockage dynamique, puis à le divulguer intentionnellement.

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

Selon cppreference.com :

Sépare le thread d'exécution de l'objet thread, ce qui permet à l'exécution de se poursuivre indépendamment. Toutes les ressources allouées seront libérées une fois le thread terminé.

Après avoir appelé detach, *thisne possède plus de thread.

Par exemple:

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

Remarquez la variable locale:, tant my_threadque la durée de vie de my_threadest terminée, le destructeur de std::threadsera appelé, et std::terminate()sera appelé dans le destructeur.

Mais si vous utilisez detach(), vous ne devriez plus utiliser my_thread, même si la durée de vie de my_threadest terminée, rien n'arrivera au nouveau thread.