pthread - Comment faire pour démarrer un nouveau thread sans appeler les rejoindre?

Je veux commencer un nouveau thread, le thread principal. Je ne peux pas utiliser les rejoindre car je ne veux pas attendre le thread pour quitter et de reprendre l'exécution.
Fondamentalement, ce que j'ai besoin est quelque chose comme pthread_start(...), ne peut pas le trouver.

Edit:
Comme toutes les réponses suggérées create_thread devrait commencer à enfiler le problème est que dans le simple code ci-dessous cela ne fonctionne pas. La sortie du programme ci-dessous est le "fil conducteur". Il semble que la sous-thread jamais exécuté. Une idée d'où je me trompe?
compilé et exécuté sur Fedora 14 GCC version 4.5.1

void *thread_proc(void* x)
{
   printf ("sub thread.\n");
   pthread_exit(NULL);
}


int main()
{
    pthread_t t1;
    int res = pthread_create(&t1, NULL, thread_proc, NULL);
    if (res)
    {
        printf ("error %d\n", res);
    }

    printf("main thread\n");
    return 0;
}

Qu'est-ce que la sortie du programme? Voir la réponse par user396672 pour la cause probable (thread principal se termine, et les os tue tous les fils avant de les subthread est terminé).
Si vous return de main, votre programme se termine. Appel pthread_exit dans le thread principal à la place.
Ou tout simplement ajouter pthread_join(t1, NULL); avant le return 0;

OriginalL'auteur Ohad Horesh | 2011-05-31

c c++linux multithreading pthreads

17

La fonction pour démarrer le thread est pthread_create, pas
pthread_join. Vous utilisez uniquement pthread_join lorsque vous êtes prêt à attendre,
et resynchroniser, et si vous détachez le fil, il n'y a pas besoin d'utiliser
elle à tous les. Vous pouvez aussi vous joindre à partir d'un autre thread.

Avant de quitter (soit par l'appel de exit ou par retour de main),
vous devez vous assurer qu'aucun autre thread n'est en cours d'exécution. Un moyen (mais pas
la seule) de faire est de rejoindre tous les threads que vous avez
créée.

+1 Effectivement, vous n'avez pas pour attendre les autres threads avant de quitter. L'appel de exit() s'arrête automatiquement tous les threads. Si vous souhaitez résilier gracieusement vous souhaiterez peut-être utiliser pthread_barrier ou pthread_join.
Lindback Appel exit() va mettre fin à tout le processus, qui, bien sûr, met fin à tous les threads. Mais ce n'est pas un processus instantané; il y a une longue liste de mesures exit n', et la terminaison des threads est proche de la fin. Dans l'intervalle, les destructeurs de variables statiques ont été appelés, les structures de la mémoire (y compris ceux de malloc?) nettoyé, etc., etc. En attendant, d'autres threads de continuer à fonctionner, en utilisant éventuellement des ressources qui ont été nettoyés. C++11 ajoute également des restrictions.
Ooooooh, je vois maintenant. Je me demandais pourquoi mon fils n'a pas exécuté que si j'ai appelé pthread_detach... je comprends comment ça fonctionne maintenant. C'est vraiment bon pour les démons ou les services, qui ne sont pas toujours à la sortie (au moins en théorie). Merci!

OriginalL'auteur James Kanze
6

le comportement de votre code dépend de l'ordonnanceur; probablement le principal programme de sorties avant de printf dans le fil de discussion a été exécuté. J'espère que simple sommeil(some_seconds) à la fin du main() va entraîner le fil de sortie apparaissent 🙂

Merci @user396672 en effet, c'était le problème. - Je choisir James réponse étant donné qu'elle correspond à la question d'origine mais au moins je vous ai donné un upvote 🙂
C'est la réponse correcte. La solution correcte à attendre le engendré thread à exécuter avant de retourner main() est l'appel de pthread_join(t1, NULL), avant de retourner. pthread_create() n'offre aucune garantie que le thread lance dès qu'il renvoie. De plus, le temps jusqu'à ce que le thread est en fait prévue ci est à durée indéterminée. Soit vous signal avec une variable de condition qui l'a engendré thread terminé son travail, soit vous attendez.

OriginalL'auteur user396672
3

la join appel attend pour le fil de résilier et de sortie.

si vous voulez que votre thread principal pour continuer son exécution, tandis que l'enfant thread est en cours d'exécution, ne l'appelez pas join: l'enfant thread s'exécuter simultanément avec le thread principal...

Cela fonctionne bien pour moi. Mais est-ce la norme?
oui, il est. ce qui fait que vous pensez ne pas appeler join() n'est pas standard ? (pour être honnête, vous devez toujours appeler join() à la fin du thread principal pour s'assurer que tous les enfants de filetage fin avant de quitter l'application)
Pensez-vous que je peux tout simplement appeler detach() lors de la de la le destructeur de la classe?
il dépend de la conception. vous pouvez le faire, mais il va laisser le thread de courir sur son propre: c'est une sorte de fuite de ressources que je n'aime pas. (mais nous sommes à la dérive loin de la question initiale)

OriginalL'auteur Adrien Plisson
2

Il suffit de créer le thread avec le détachement de l'attribut défini sur on. Pour ce faire, vous pouvez soit appeler pthread_detach après le thread a été créé ou pthread_attr_setdetachstate avant sa création.

Lorsqu'un thread est détachée, le parent thread n'avez pas à attendre et il ne peut pas récupérer sa valeur de retour.

OriginalL'auteur Blagovest Buyukliev
1

vous devez appeler pthread_exit à la fin de l'homme(), qui sera la cause principale d'attendre autre thread pour démarrer et quitter.
Ou vous pouvez appeler explicitement pthread_join attendre le nouveau thread

Sinon, en cas de retour, le processus est tué et tous les threads, il sera tué.

OriginalL'auteur cheng yang
0

Le thread démarre automatiquement lorsque vous créer.

Aussi, il ne garantit pas une réponse, mais si vous ne joignez pas le fils que vous avez créé, votre programme va fermer avant qu'ils ne font rien d'exécution dans le thread principal va aller sur.

OriginalL'auteur Klas Lindbäck

Ne pas vous juste besoin d'appeler pthread_create?

static void *thread_body(void *argument) { /* ... */ }

int main(void) {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_body, NULL);
    /* ... */

OriginalL'auteur Thomas Padron-McCarthy

Vous devez vous connecter pour publier un commentaire.