est-il nécessaire de faire appel à pthread_join()

J'ai créer plus de 100 fil de ma main() donc je voulais juste savoir qui dois-je appeler pthread_join() avant de quitter ma main().
Aussi je n'ai pas besoin de données générées par ces fils, fondamentalement, tous les threads sont en train de faire un travail indépendant de main() et d'autres threads.

OriginalL'auteur nav_jan | 2012-05-15

  1. 21

    pthread_join fait deux choses:

    1. Attendre le fil à la fin.
    2. Nettoyer toutes les ressources associées avec le fil.

    Si vous quittez le processus sans avoir à se déplacer, puis (2) sera fait pour vous par l'OS (bien que ce ne sera pas faire des thread de nettoyage d'annulation, juste nuke le fil de l'orbite), et (1) ne sera pas. Donc, si vous avez besoin d'appeler pthread_join dépend si vous avez besoin d' (1) de se produire.

    Si vous n'avez pas besoin de l'exécution du thread, alors que tout le monde est en train de dire que vous pouvez aussi bien le détacher. Un décollement de fil ne peut pas être rejoint (donc vous ne pouvez pas attendre son achèvement), mais ses ressources sont libérées automatiquement si elle n'est complète.

    Merci pour votre réponse .. donc si je comprends bien .. tous mes fils serait tuée si threads principaux sorties .. donc pour éviter qu'il soit je dois appeler pthread_join() ou pthread_detach() ... pour mon scénario que je n'ai pas besoin de main() de garder en attente pour tous les threads pour terminer, je vais appeler tout simplement pthread_detach() et à la sortie de mon main (), et enfin le système d'exploitation en toute sécurité de libérer toutes les ressources utilisées par tous les threads sur leur achèvement ??
    pas de. Si vous détachez les filets, ils seront tués lorsque le processus s'arrête, c'est pourquoi j'ai dit "si vous n'avez pas besoin de l'exécution du thread, on peut ainsi se détacher". Si vous en avez besoin pour exécuter, vous devez joindre à elle.

    OriginalL'auteur Steve Jessop

  2. 2

    Lorsque vous quittez, vous n'avez pas besoin de joindre parce que tous les autres threads et les ressources seront automatiquement supprimés. Cela suppose que vous voulez vraiment tous les threads d'être tué lors de la main sorties.

    Si vous n'avez pas besoin de se joindre à un fil, vous pouvez créer un "détaché" thread à l'aide de pthread_attr_setdetachstate sur les attributs avant de créer le thread. Détacher les threads ne peuvent pas être joint, mais ils n'ont pas besoin être rejoint.

    Donc,

    1. Si vous voulez que tous les threads pour achever avant la fin du programme, joindre le thread principal qui fait ce travail.

    2. Comme alternative, vous pouvez créer des threads comme détaché, et le retour de main après tous les fils de sortie, la coordination de l'aide d'un sémaphore ou mutex+variable de condition.

    3. Si vous n'avez pas besoin de tous les threads pour terminer, il suffit de le retourner de main. Tous les autres threads seront détruits. Vous pouvez également créer des threads comme détaché de threads, ce qui peut réduire la consommation de ressources.

    Notez que dans le cas (2), votre coordination pouvez vous assurer de ne pas quitter jusqu'à ce que les fils ont fait tout ce qu'ils ont à faire avant de poster le sémaphore ou condvar. Ce devrait être assez bon pour toutes fins pratiques, mais il ne fait pas de vous assurer de ne pas quitter jusqu'à ce que les fils ont quitté, depuis leur sortie à un certain temps indéterminé après ils exécuter le code qui informe votre thread principal que quelque chose d'intéressant s'est produit.

    OriginalL'auteur Dietrich Epp

  3. 1

    Par défaut un thread exécute attaché, cela signifie que les ressources nécessaires sont conservés dans de l'utiliser jusqu'à ce que le thread est joint.

    Qu'à partir de la description de votre personne, mais le fil lui-même doit être le fil de ses ressources, de sorte que vous pourriez créer le thread détaché ou détacher le fil avant de l'avoir commencé.

    Pour détacher un fil après sa création appeler pthread_detach().

    De toute façon, si vous voulez vous assurer que tous les fils sont partis avant la fin du programme, vous devez exécuter les fils attachés et se joindre à eux avant de quitter le thread principal (le programme).

    OriginalL'auteur alk

  4. 1

    Par défaut threads dans la bibliothèque pthreads sont créés en tant que recrutables.

    Threads peut, toutefois, se détacher, le rendu n'est plus joignable. Parce que les consomment des ressources système jusqu'a rejoint, tout comme les processus de consommer des ressources jusqu'à leur parent appelle wait(), les threads que vous n'avez pas l'intention de joindre doit être détachée, ce qui est une bonne pratique.

    Bien sûr, une fois que la routine principale sorties, tout threading ressources sont libérées.

    Si nous ne parvenons pas à le faire(détachement), puis, lorsque le thread se termine, il produit le thread équivalent d'un zombie processus. Côté de gaspillage de ressources système, si assez de fil zombies s'accumulent, nous ne serons pas en mesure de créer des threads supplémentaires.

    OriginalL'auteur Gowtham Munukutla

  5. 0

    Si vous voulez être sûr que votre fil ont fait terminé, vous voulez appeler pthread_join.

    Si vous ne le faites pas, alors la résiliation de votre programme de résilier tous les inachevé fil brusquement.

    Cela dit, votre main peut attendre un temps suffisamment long jusqu'à la sortie. Mais alors, comment pouvez-vous être sûr que c'est suffucient?

    OriginalL'auteur Didier Trosset

  6. -1

    Si votre principale se termine, votre application se termine et votre fils mourir... Alors vous avez besoin pour utiliser le thread rejoindre (ou de l'utilisation de la fourche à la place).

    OriginalL'auteur fbernardo