Bonjour à tous,

Je viens vous voir car j'ai besoin d'un coup de main.
Je possède une liste de threads qui font globalement la même choses. Ils sont numérotés de 1 à N je voudrais connaitre dans quelle ordre ils se sont terminés.

Pour le moment la seule idée que j'ai eu est de mettre à jour une liste avec le numéro du thread. Pour éviter que 2 ou + threads aient accès à la liste en même temps j'ai mis un mutex dessus.

Ce qui donne en gros :

fonction thread(
le thread fait son job
appel fonction add_list
exit_thread
)

et dans la fonction add_list

fonction add_list(
mutex_lock
update list
mutex_unlock
)

Vous pensez que c'est la bonne idée ? ou il y a un meilleur moyen de faire ça ?

Merci par avance,

Je n'ai pas compris ce que tu cherches a faire globalement. Decris plus ton probleme.

J'ai créé un nombre N de threads et je les lance en même temps. Tous ces threads s'exécutent donc en même temps.

Mon but est de savoir dans quel ordre ils se sont terminés.

Je dois pourvoir dire : par exemple

1er thread : thread numéro 5 (le + rapide)
2eme thread : thread numéro 12
3eme thread : thread numéro 1
etc...

Pour ça j'utilise une liste. Dès que le thread arrive à la fin il écrit son numéro dans une liste. Cette liste étant accessible par N threads devient donc une ressource critique je gère donc l'accès à cette liste par un mutex.

Hum oui c'est bien ton idée de liste mais vu que c'est des opérations asynchrones tu vas récupérer le résultat où et que vas-tu en faire?

John, si tu veux connaitre l'ordre pourvanalyser du desiquilibre de charge, le mieux est certainement de regarder l'heure et de l'enregistrer dans un tableau puis de le trier.

Merci à vous deux.

Oui j'avais aussi pensé à utiliser un tableau avec le temps d'exécution du thread. Pour le moment j'ai mis en place, ma première solution ça semble marcher. Mais l'idée d'un tableau me semble meilleur pour manipuler les résultats après.

les mutex de winapi et pthread ne sont pas FIFO [1], si plusieurs threads se retrouvent en même temps dans la zone d'attente, l’ordre n'est plus garanti.

[1] http://fr.wikipedia.org/wiki/First_in,_first_out

C'est vrai, je n'y pensais pkus. En pratique personne ne fait des mutex fifo parceque ca coute trop cher.

Je viens d'en parler à mon prof, il m'a dit qu'on ne peut savoir si un mutex est FIFO. Il m'a conseillé d'utiliser un sémaphore plutôt.

Mais je ne comprend pas très bien car pour moi un sémaphore si je le place au même endroit dans le code se comportera comme un mutex. La différence entre un sémaphore binaire et un mutex vient que pour le mutex seul le thread qui est possession du mutex peut le relâcher.

Donc du coup je suis un peu perdu là.

Je vais peut-être dire une bêtise mais pourquoi ne pas faire un affichage à la fin du traitement dans la fonction thread qui va indiquer que le thread n°x a fini sont boulot?

fonction thread(
le thread fait son job
print thread n°x finished
exit_thread
)

son boulot*

Malheureusement non j'ai besoin d'utiliser cette liste après.

Quelle platforme?
Perso je ferai sans mutex, avec in interlockedincrement.
Par exemple http://pastebin.com/A6pYvKxF
(j'ai pas fait de tests d'erreurs, mais ca donne une idee)

/k

Sur Linux,

Ok merci je vais regardé comment un interlockedincremet marche .

Par contre, ne l'ayant pas vu durant le cours je pense qu'il faut mieux que je me rabatte sur une autre solution.

kufa, j'ai l'impression que ca se repose sur une instruction atomic comme un fetch_and_add, et je ne suis pas convaincu que ca soit FIFO comme operation. ?