Threads dans un for

Version imprimable

Threads dans un for

Bonjour,

Afin d’accélérer mon application, je souhaite utiliser des threads sur des opérations distinctes mais qui prennent un certain temps. Cependant, je ne sais pas comment implémenter une gestion de threads dans mon cas actuel.

Mon code ressemble à cela :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 private List<Map> maFonction(Collection<myObject> params) throws SQLException{ List<Map> maps = new ArrayList<Map>(); for (myObject o : params) { /** * bindMyObject() prend un temps significatif */ maps.add(Processor.bindMyObject(o)); } return maps; }
Dans mon cas, chaque appelle à bindMyObject() prend un temps relativement long. Ce temps est nécessaire et compréhensible, mais chaque appel à la fonction est bien détaché et pourrait très bien s'exécuter en parallèle.

Mais là où cela me pose un soucis, c'est que le retour de bindMyObject doit être stocké dans ma variable maps, qui une fois remplie est retourné.

Sans valeur de retour de la part de bindMyObject(), je ferais un extends Threads sur la class Processor puis je lancerai mes threads à la suite. Avec join() j'aurai attendu (entre ma boucle for et mon return) que chaque thread termine bien son execution et je pense que cela aurait été bon.

Mais ici avec une valeur de retour je ne sais pas vraiment comment faire. Pourriez-vous me guider sur cette question ?

Merci :)

02/08/2012, 19h05
mikael.gibert

Tu peux regarder du côté du framework Executor et des Future<V> dans les cours et tutoriels java : http://java.developpez.com/cours/
03/08/2012, 15h36
Steph0

Bonjour,

Merci, en effet le framework Executor semble être le plus indiqué. Cependant j'ai un petit soucis sur la manière d'implémenter cela.

Avec le framework Executor, on dispose de l'instruction du CompletionService et de son instruction take(). Mais cette instruction nécessite de connaitre par avance le nombre de retour attendus. Sauf que le nombre d'objets dans ma Collection params n'est pas fixe, je peux avoir 10 threads à faire comme 50 selon le nombre d'objets dans params.

Comment exécuter les Processor.bindMyObject(o) en parallèle (threads), gérer les retour en les intégrant au fur et à mesure dans ma map et faire mon return de ma map une fois tous les retours de threads récupérés et insérés dans celle-ci ?

Merci :)
03/08/2012, 18h14
JoeChip

Peut-être en ajoutant un thread qui s'occupe de tout ça ? genre il lance les threads, attend qu'ils soient tous revenus, puis fait la map et la renvoie...?
04/08/2012, 11h14
tchize_

Tu lance ton executorservice. Ensuite dans ta boucle, tu crée tes future, tu les stockes dans une list et tu les ajoute au fur et à mesure au service.
Après la fin de la boucle, tu attends la fin du service. Ensuite tu passe sur chaque future pour récupérer son résultat et tu les ajoute au fur et à mesure dans la map, tout simplement.
07/08/2012, 17h26
Steph0

Bonjour,

Désolé pour ma réponse tardive.

@tchize_ : cette solution me semble la plus adaptée avec l'utilisation du framework Executor. Je vais implémenter celle-la. :)

Merci :)

Ou sinon :

Tu crée une classe ProcessorThead :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class ProcessorThread implements Runnable{
   private List<Map> maps;
   private MyObject ojb;
 
   public ProcessorThread(List<Map> maps, MyObject obj){
        this.maps = maps;
        this.ojb = ojb;
   }
 
   public void run(){
         Map res = Processor.bindMyObject(ojb);
         synchronized(maps){
               maps.add(res);
         }
   }
}

Et dans ta classe principale :

Code:

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
private List<Map> maFonction(Collection<myObject> params) throws SQLException{
        List<Map> maps = new ArrayList<Map>();
        List<Thread> threads = new ArrayList<Thread>();
 
 
        for (myObject o : params) {
             // Création des threads
             ProcessorThread pt = new ProcessorThread(o);
             Thread th = new Thread(pt);
             threads.add(th);
             th.start();
        }
 
        // Attente que tous les threads soient terminées
        boolean ended = true;
        do{
            ended  = true;
            for(Iterator<Thread> it = threads.iterator(); it.hasNext();){
                 Thread th = it.next();
                 if(th.isAlive()){
                      Thread.sleep(100);
                      ended  = false;
                      break;
                 }
            }
        }while(! ended); 
 
        return maps;
    }

La classe ProcessorThread sera le thread qui devra exécuter ton traitement.
La fonction maFonction est en deux parties :
1 - On crée et on démarre les threads (en les stockant dans une liste)
2 - On crée une boucle qui tourne a interval régulier, et termine uniquement quand tous les threads ont terminés leur exécution

10/08/2012, 11h43
JoeChip

Citation:

Peut-être en ajoutant un thread qui s'occupe de tout ça ? genre il lance les threads, attend qu'ils soient tous revenus, puis fait la map et la renvoie...?

Euh -1 pourquoi là ?