Bonjour,
Je crée 12 threads posix avec la fonction pthread_create.
Il y a 10 threads qui son censés se terminer, donc lorsque je fais un pthread_join à la fin du programme, le statut est bien à finish.
2 threads tournent en boucle, je dois les arrêrter avec pthread_cancel.
Le problème, c'est que lorsque j'applle pthread_cancel, il y a des allocations en plus (que je vois avec valgrind) qui ne sont pas libérées.
 
Comment remédier à ce problème??
 
Merci d'avance!

il me semble qu'un thread créé en non-détaché doit obligatoirement être libéré par un pthread_join.
 
Lorsque tu veux terminer un thread de façon synchrone, c'est assez facile en passant par une variable de controle + pthread_join.  
 
Par contre lorsque tu ne sais pas quand se termine le thread, c'est plus difficile de faire le join dessus (je n'ai pas trouvé de méthode idéale pour libérer les ressources ).

Je fais un pthread_join pour les deux threads (après le pthread_cancel). Ce qui me fait 17 allocs pour 12 free. Si je mets pas le pthread_cancel, ca me fait 12 allocs pour 12 frees! Le problème si je fais ca,  c'est que je dois attendre que les deux threads se terminent, ce qui parfois prend plusieurs minutes !

le pthread_cancel interrompt et termine directement la fonction de thread là où elle en était. Donc si tu avais des désallocations à faire à la terminaison de ton thread, elles ne seront pas faites.
 

Et on peut pas remédier à ça?
Je supprime tous les sémaphores que j'ai initialisé avant de faire le cancel et ça me met toujours 15 allocs, 10 frees

un exemple.
 
Si tu fais ça :
 

 
Si tu fais un pthread_cancel sur le thread dont la fonction est thread_cb, le malloc ne sera pas libéré car le code ne passera pas par le free.  
 
Le mieux est que tu postes ton code ou une partie pour qu'on puisse identifier les ressources non désallouées.

Tu peux:
- allouer tes ressources dans ton thread appelant
ou
- utiliser un sémaphore qui dès qu'il est reçu par ton thread fils déclenche le nettoyage des ressources allouées et quitte le thread

La première méthode est efficace si tu est capable de prédire les ressources utilisées par ton thread et de les lui transmettre au facilement.

La deuxième méthode est la plus souple mais aussi plus complexe à programmer, un pooling sur le sémaphore devant être effectué fréquemment si tu veux de la réactivité.