URL: https://linuxfr.org/forums/programmation-c/posts/pthread-mutex-bien-s-en-servir Title: pthread : mutex, bien s'en servir Authors: Mais qui suis-je ? :) Date: 2013年06月14日T13:21:45+02:00 License: CC By-SA Tags: pthread, c et mutex Score: 0 Salut, Je suis en train de jeter un œil sur pthread (oui je sais C++11 arrive c'est plus la peine) Mais le bon usage des mutex n'est pas clair pour moi + pthread_mutex_lock(&monmutex) : Si je comprend bien, lorsque plusieurs threads vérouillent le mutex, les autres se mettent en attente jusqu'à c que le mutex soit libéré ? + pthread_cond_wait(signal,mutex) Va créer une sorte de slot qui attend un signal et va simplement attendre le signal, mais à quoi sert le mutex ? Est-ce que je dois faire référence au mutex avant d’appeler ma fonction ? + Est-ce que je peux locker un stream avec un mutex ? i.e. contrôler l'écriture sur cout ? Voilà un bout de code, qui se contente d'afficher le contenu d'un vecteur d'entier, ça tourne, je soupçonne qu'il reste un heisenbug à l'intérieur, mais surtout j'ai mis mes lock un peu au hasard et j'aimerais faire ça proprement, Le but du code est simple, j'ai un thread mère qui itére le vecteur et lance des threads filles qui ici se contente d'afficher le contenu du vecteur, sachant que je veux un nombre donnés de threads filles. ```c //Nthread, mutex_* cond_* sont des globales, c'est moche, mais pour un test c'est rapide void* Mythread2(void* data) { //Ici par intéret pédago, on se contente d'afficher un entier, mais la tache pourrait être plus complexes pthread_mutex_lock(&mutex_outlock); //Est-ce que ça locke cout ? apparement non cout << ">>>> "<< *(reinterpret_cast(data)) << endl; pthread_mutex_unlock(&mutex_outlock); pthread_mutex_lock(&mutex_launchnew); //Le thread est presque finit on décrémente le compteur de thread Nthread--; pthread_cond_signal (&cond_launch); pthread_mutex_unlock(&mutex_launchnew); } void* MotherThread(void* data) { //L'idée c'est d'avoir un thread qui s'assure qu'on utilise pas plus de threads que ce que l'on veut const int MaxThread=4; //C'est pas très C++ mais apparemement c'est ce que veut pthread vector* params=reinterpret_cast*>(data); vector::iterator iter=params->begin(); while (Nthreadend()) break; pthread_t thread; int* pval=NULL; pval=&(*iter); pthread_create(&thread, NULL,Mythread2, reinterpret_cast(pval)); ++Nthread; ++iter; } while (iter!=params->end()) { //Ici je veux locker mon compteur de threads pour garder un nombre //constants de threads qui tournent pthread_mutex_lock(&mutex_launchnew); pthread_t thread; //On va attendre qu'un thread soit finit pour en lancer un autre // C'est surement plus éléguant qu'un while(true) pthread_cond_wait(&cond_launch,&mutex_launchnew); while (Nthread(pval)); Nthread++; ++iter; cout << "Starting new thread, at the moment there is " << Nthread << "running" << endl; } //On a lancé le thread on peut dévérouiller pthread_mutex_unlock(&mutex_launchnew); } } ``` En relisant le code, j'ai 2-3 doutes qui viennent, + Si un thread se finit alors que mon autre thread tourne déjà, que devient le slot qui attend la fin d'un thread pour en lancer un ? J'imagine que le while est une solution au problème cas si je manque la fin d'un thread je serais avertit lorsque le prochain se termine. + Il y a pas un moyen plus éléments de compter le nombre de thread en cours ? car incrémenter/décrementer un compteur c'est moche merci pour vos conseils/commentaires