Dans le code suivant, je crée un certain nombre de threads, et chaque threads dort pendant quelques secondes.
Cependant, mon programme principal n'attend pas que les fils finissent, j'étais sous l'hypothèse que les threads continueraient de courir Jusqu'à ce qu'ils finissaient par eux-mêmes. P>
est-il utile de faire des fils continuer à courir même si le fil d'appel se termine. P>
#include <pthread.h>
#include <iostream>
#include <cstdio>
#include <cstdlib>
int sample(int min,int max){
int r=rand();
return (r %max+min );
}
void *worker(void *p){
long i = (long) p;
int s = sample(1,10);
fprintf(stdout,"\tid:%ld will sleep: %d \n",i,s);
sleep(s);
fprintf(stdout,"\tid:%ld done sleeping \n",i,s);
}
pthread_t thread1;
int main(){
int nThreads = sample(1,10);
for(int i=0;i<nThreads;i++){
fprintf(stderr,"\t-> Creating: %d of %d\n",i,nThreads);
int iret1 = pthread_create( &thread1, NULL, worker, (void*) i);
pthread_detach(thread1);
}
// sleep(10);//work if this is not commented out.
return 0;
}
4 Réponses :
Chaque programme a un fil principal. C'est le fil dans lequel votre fonction principale () exécute. Lorsque l'exécution de ce fil se termine, le programme se termine avec tous ses threads. Si vous souhaitez que votre fil principal attendent d'autres threads, l'utilisation doit utiliser pthread_join fonction
Lorsque l'exécution du fil principal se termine, au moins sous Linux, le programme / processus ne se termine pas, il fonctionne comme un zombie jusqu'à ce que les autres threads finissent, puis le programme / processus se termine également. Pour vérifier cela, codez un filetage qui dort simplement pour n secondes, puis du thread principal crée le fil, puis émettez pthread_exit (0) à partir du fil principal et regardez le processus vivant, mais dans l'état zombie, puis après la fin du fil se termine. qui déclenche le programme / processus à finir aussi.
Vous devez garder une trace des threads. Vous ne faites pas cela parce que vous utilisez la même variable thread1 à chaque thread que vous créez.
Vous suivez les threads en créant une liste (ou une matrice) de EDIT:
Eh bien, c'est vraiment paresseux de vous de ne pas garder une trace des fils de course. Mais vous pouvez accomplir ce que vous voulez en ayant un Var global (protégé par un mutex) qui est incrémenté juste avant la fin des fils. Ensuite, dans votre thread principal, vous pouvez vérifier si ce VaR correspond à la valeur que vous souhaitez. Dites pthread_t types que vous passez à la fonction pthread_create () fonction. Ensuite, vous pthread_join () ces threads de la liste.
NThtheads dans votre code d'échantillon.
Si vous utilisez la deuxième solution, n'oubliez pas que tous les accès à la variable doivent être synchronisés.
Vous devez rejoindre chaque fil que vous créez:
int main()
{
int nThreads = sample(1,10);
std::vector<pthread_t> threads(nThreads);
for(i=0; i<nThreads; i++)
{
pthread_create( &threads[i], NULL, worker, (void*) i)
}
/* Wait on the other threads */
for(i=0; i<nThreads; i++)
{
status* status;
pthread_join(threads[i], &status);
}
}
Vous avez appris que votre hypothèse était fausse. Le principal est spécial. La sortie principale va tuer vos discussions. Donc, il y a deux options:
Utilisez faire quelque chose à garder la principale vivante. Cela peut être n'importe quoi d'une boucle (stupide et inefficace) à tout appel de blocage. puisque Martin a montré pthread_exit pour quitter la principale. Cette fonction vous permettra de quitter la principale mais de garder d'autres threads en cours d'exécution.
pthread_join est courant car il va bloquer mais vous donnera également l'état de retour des threads, si vous êtes intéressé et nettoyer les ressources du fil mort. Mais aux fins de garder le principal de terminer tout appel de blocage fera par exemple. Sélectionnez, lisez un tuyau, un bloc sur un sémaphore, etc.
join () , voici pthread_exit () :
Si c'était une interface utilisateur graphique, oui, cela serait vrai car il y a une boucle de message. Vous devez avoir une condition pour continuer à courir jusqu'à ce que tous les fils soient terminés, tels que rejoindre.