Attente d'un thread parmis plusieurs

[sone47]

Bonjour,

J'ai actuellement un main thread qui a besoin de lancer X threads secondaires.
Je voudrais pouvoir fixer Y, nombre de threads pouvant tourner en parallèle.
Des que 1 thread est terminé, le main relance un nouveau jusqu'a avoir lancé ces X threads.

Actuellement tout est lancé d'un trait puis on boucle sur tout les threads en faisant un join, ce qui fait que mon attente depend du premier thread lancé..
Et donc si le dernier est le plus rapide, je ne le vois pas.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
 
// Lancement
for(int i=0; i<nb_thread_a_lancer; i++)
{
    monThread[i].run(); // Lancement du thread i
}
 
// Attente des threads
for(int i=0; i<nb_thread_a_lancer; i++)
{
    monThread[i].wait(); // Encapsule un join
}

J'aimerais mettre en place un genre de select sur les threads lancé,
Je pensais a 2 solutions:

1/ Mettre en place un semaphore a Y etats (je ne sais pas si on dit comme ça), etant habitué des mutex (donc a 2 etats), je ne vois pas trop le principe avec un semaphore a Y etats:
Je définis dans mon main thread ce semaphore a Y etats, chaque thread lancé tente un wait sur le semaphore (son compteur interne est decrementé), une fois que les Y threads tournent le Y+1 n'est pas autorisé et donc attend le post d'un thread tournant. Est ce ça ?


2/ Utiliser un principe de fifo de message, mon main thread donne cette fifo a chaque thread lancé, une fois qu'un thread se termine il poste un msg dedans capté par le main qui lance un nouveau thread etc. Sauf que du coup j'aurais une boucle active dans mon main pour capter un message reçu.

3/ ??

Qu'est qui est fait en général ?
Avec une utilisation de la lib standard (mais pas c++11) et boost.

Merci d'avance

[Iradrille]

Tu peux utiliser un threadpool, voir ici par exemple. (la version C++11 de ce même code possède quelques explications supplémentaires, ici)

En gros, x threads de lancés et qui restent en attente tant qu'il n'y a rien à exécuter.

Et les threads se servent dans une liste de taches à exécuter.

Ça à l'avantage d'économiser le coût de construction / destruction des threads (non négligeable pour des taches très courtes).

[sone47]

Merci,

Exact ça peut etre pas mal car la je me suis codé un manageur de thread avec un sémaphore avant le lancement de la tache, libéré a la fin de celle ci.
Mais effectivement du coup création de thread à chaque coup.
Les taches ne sont pas courtes mais il y en une quantité non négligeable.