Qu'arrive-t-il aux threads détachés lorsque la fonction `main()` se termine en C ?

Que se passe-t-il lorsque les threads détachés survivent à Main() ?

En C, les threads peuvent être détachés à l'aide de detach(), leur permettant de s'exécuter indépendamment de l'objet std::thread qui les a initialement créés. Cependant, le comportement de la norme pour les threads détachés à la sortie de main() reste ambigu.

Silence standard et effets implicites

Ni la section 1.10 ni 30.3 du projet C 14 ne sont explicitement définit le sort des threads détachés lorsque main() se termine. Cette ambiguïté soulève plusieurs questions :

• Le détachement de threads rend-il l'utilisation de detach() un comportement indéfini ?
• Si oui, y a-t-il des effets définis en cas de manque de main() avec des threads détachés toujours en cours d'exécution ?

Le manque de directives explicites suggère que manquer de main() avec des threads détachés doit avoir des effets définis, comme l'arrêt les threads détachés rendraient essentiellement detach() dénué de sens.

Limites implicites

Bien que la norme n'indique pas explicitement ce qui arrive aux threads détachés, elle fournit certaines contraintes :

• Le thread détaché ne peut pas accéder aux variables (automatiques ou locales du thread) d'autres threads ou objets statiques lorsque main() quitte.
• Le thread doit respecter les restrictions des gestionnaires de signaux après la destruction d'objets statiques, ce qui exclut la plupart de la bibliothèque standard C, à l'exception des opérations atomiques.

Rejoindre Discussions détachées

La question de savoir si les discussions détachées peuvent un jour être jointes est également abordée dans la réponse. La réponse révèle que les threads détachés peuvent en effet être joints à l'aide de la famille de fonctions *_at_thread_exit (notify_all_at_thread_exit(), std::promise::set_value_at_thread_exit(), etc.).

Atténuation des comportements non définis

Pour éviter un comportement non défini lorsque main() se termine avec threads détachés en cours d'exécution, envisagez les stratégies suivantes :

• Rejoignez manuellement les threads détachés à l'aide d'une fonction _at_thread_exit qui signale l'achèvement.
• Assurez-vous que les threads détachés exécutent uniquement du code qui serait sûr pour un signal gestionnaire après un objet statique destruction.

Conclusion

Bien que la norme C ne définisse pas explicitement le comportement des threads détachés lorsque main() se termine, elle fournit des limitations et des implications qui suggèrent effets définis. En respectant ces limitations et en utilisant la famille de fonctions *_at_thread_exit, les programmeurs peuvent gérer les threads détachés et éviter les comportements non définis.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!