[JavaFX2] Traitement après la fin des Tasks

Version imprimable

Bonjour,

J'ai un ensemble de threads (Tasks) qui s'exécutent en même temps et mon problème est que j'ai un traitement que j'aimerais lancer juste après la fin de tous les threads mais je n'arrive pas à le faire.

Pour mieux expliquer ma situation, je vous montre mon code :

Contrôleur :
Code:

1 2 3 4 5 for (int k=1; k<=numberOfThreads;k++) { ThreadTestExecutor newThread = new ThreadTestExecutor(TestConfigPage.getRequestsList(), k); newThread.startTest(); } // Ici, aprés la fin de tous les threads, je veux éxécuter un autre traitement
Le problème est que si je mets le nouveau traitement de cette façon, il ne s'exécute pas à la fin des threads mais en parallèle à leur exécution.

La structure de mon thread est la suivante :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class ThreadTestExecutor{ public void startTest(){ new Thread(task).start(); } public Task task = new Task<Void>() { @Override public Void call() { // Traitement return null; } }; }
Comment pourrais-je bloquer ce traitement jusqu'à la fin des threads ?

Merci d'avance pour votre aide.

22/07/2013, 15h26
jeffray03

as tu essayé

Code:

thread.sleep(Int value);

afin de bloquer le thread et executer ce donc tu as besoin?
Eric
23/07/2013, 00h14
albert55

Le problème est que je ne veux pas bloquer l'ensemble des threads qui s'exécutent, je veux plutôt attendre leur fin avant de lancer mon nouveau traitement.

Peut-être plus avec quelque chose comme ça (j'ai pas testé) :

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public class ThreadTestExecutor{
   private Task task = new Task<Void>() {
        @Override public Void call() {
 
             // Traitement
            return null;
        }
    };
 
    private Thread thread = null;
 
    public ThreadTestExecutor() {
      task.setOnSucceeded(new EventHandler<ActionEvent>(){
        @Override
        public void handle(ActionEvent event) {
          thread = null;
        }
      });
      task.setOnCancelled(new EventHandler<ActionEvent>(){
        @Override
        public void handle(ActionEvent event) {
          thread = null;
        }
      });
      task.setOnFailed(new EventHandler<ActionEvent>(){
        @Override
        public void handle(ActionEvent event) {
          thread = null;
        }
      });
    }
 
    public synchronized void startTest(){
         if (thread != null) {
           return;
         }
         thread  =  new Thread(task);
         thread.start();
    }
 
   public synchronized void join() throws InterruptedException {
     if (thread == null) {
       return;
     } 
     thread.join();
   }
}

Et :

Code:

1
2
3
4
5
6
7
8
9
10
11
List<ThreadTestExecutor> executors = new ArrayList<>(numberOfThreads);
for (int k=1; k<=numberOfThreads;k++) {
  ThreadTestExecutor newThread = new ThreadTestExecutor(TestConfigPage.getRequestsList(), k);
   executors.add(newThread);
   newThread.startTest();
}
for (ThreadTestExecutor executor : executors) {
  executor.join();
}
executors.clear();
// Ici, aprés la fin de tous les threads, je veux éxécuter un autre traitement.

Après c'est un peu étrange d'utiliser des Task sans Service mais pourquoi pas...