Discussion :

[albert55]

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 :

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

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 :

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

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.

[jeffray03]

as tu essayé

Code :

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

thread.sleep(Int value);

afin de bloquer le thread et executer ce donc tu as besoin?
Eric

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

[bouye]

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

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

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

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