Discussion :

[Sphax]

Bonjour,

Je souhaite pouvoir lancer N threads et attendre qu'un des threads termine son boulot pour en lancer un nouveau, puis attendre à nouveau qu'un thread se termine etc... Je fais d'habitude du .Net et j'aurai alors utilisé des event (ManualResetEvent) pour que chaque thread puisse signaler à son "père" qu'il a terminé, celui-ci étant en attente sur un tableau d'event. Quel mécanisme utiliser en Java svp ?

Merci

[adiGuba]

Salut,


Pourrais-tu être un peu plus précis ce n'est pas très clair... mais la solution devrait se trouver du coté des Executors...

a++

[Sphax]

Ok je vais regarder ton lien, merci. Une explication plus détaillée de mon probleme si ce n'est pas clair:

J'ai une liste de traitements à faire, je souhaite exécuter ces traitements 5 par 5 pas plus. Donc l'idée est que dans mon thread principal je puisse lancer 5 threads en leur affectant chacun un traitement et dés qu'un thread se termine en créer un autre pour lui affecter le traitement suivant (une espece de thread pool en fait, peut être qu'il existe qque chose de tout prêt ?). Question: comment attendre en Java qu'un des 5 threads soit terminé ?

[divxdede]

Ok je vais regarder ton lien, merci. Une explication plus détaillée de mon probleme si ce n'est pas clair:

J'ai une liste de traitements à faire, je souhaite exécuter ces traitements 5 par 5 pas plus. Donc l'idée est que dans mon thread principal je puisse lancer 5 threads en leur affectant chacun un traitement et dés qu'un thread se termine en créer un autre pour lui affecter le traitement suivant (une espece de thread pool en fait, peut être qu'il existe qque chose de tout prêt ?). Question: comment attendre en Java qu'un des 5 threads soit terminé ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
   /** Création du pool de threads
        */
       ExecutorService threadPool = Executors.newFixedThreadPool(5);
 
       /** Création d'une tâche à executer
        */
       Runnable doRun = new Runnable() {
           public void run() {
               System.out.println("MA TACHE S'EXECUTE PAR UN THREAD DU POOL");
           }
       };
 
       /** Mise en queue de ma tache dans le pool du thread
        *  ==> Ce dernier l'executera quand il le pourra
        */
       Future future = threadPool.submit( doRun );
 
       /** Possibilité de verifier le status de la tâche et meme de l'annuler 
        *  à l'aide de l'objet future
        */
       try {
           future.get(); // Exemple ici: Attente de la fin d'execution de la tache
       }
       catch(Exception e) { e.printStackTrace(); }
 
       /** Libération du pool (quand il ne sera plus utilisé)
        */
       try {
           threadPool.shutdown();
       }
       catch(Exception e) { e.printStackTrace(); }

[deltree]

Bonjour,
il vaut mieux d'abord connaitre les principes sur la synchro en Java:
http://java.sun.com/docs/books/tutor...ncy/index.html

Après tu choisira toi-même la solution adaptée

Ici les Executors permettent effectivement de gérer un ThreadPool, dans une solution un peu différente de celle que tu proposais.
Mais rien ne t'empêche d'implémenter ta propre solution à coup de wait/notifyAll:
http://java.sun.com/docs/books/jls/s...emory.doc.html
http://www.jchq.net/tutorial/07_03Tut.htm