Discussion :

[Steph0]

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 :

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

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

[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/

[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

[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...?

[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.

[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

[romano62880]

Ou sinon :

Tu crée une classe ProcessorThead :

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
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 :

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
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

[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...?

Euh -1 pourquoi là ?