Discussion :

[noOneIsInnocent]

Bonjour à tous

Je voudrais exécuter une tâche à intervalle régulier durant une certaine période et surtout je voudrais exploiter le résultat de cette tâche
Pour cela j'utilise les classes ScheduledExecutorService

Code :

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

1
2
3
 
ScheduledExecutorService scheduleExecutorService = Executors.newSingleThreadScheduledExecutor();
Future<?> f = scheduleExecutorService.scheduleAtFixedRate(new MyTask(), 0,INTERVALLE_EXECUTION, TimeUnit.SECONDS);

et je voudrais exploiter le résultat de ma classe MyTask mais je n'ai pas d'idée
J'ai déjà fait ce procéder avec une classe MyTask qui implémente l'interface Callable<V> mais là j'avoue que je n'ai pas d'idée
Il semble également que les classes Future soient faites pour cela mais comment ....

Mes questions sont donc:
- comment exécuter une tâche durant une période
- comment exploiter le résultat d'une tâche

[plawyx]

Tu peux utiliser une Instance de CompletionService pour lancer ton Callable et récupérer la donnée après traitement:

http://docs.oracle.com/javase/8/docs...onService.html

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
CompletionService<?> completionService = new ExecutorCompletionService<?>(scheduleExecutorService);
completionService.submit(tache);  // tache est un Callable
 
try {
   resultat = completionService.take().get(); //ou get(long timeout,TimeUnit unit)
 
} catch (InterruptedException | ExecutionException e) {
   //traitement 
}
finally {
		scheduleExecutorService.shutdown();
}

[noOneIsInnocent]

Tout d'abord merci pour ta réponse. Elle me permet de régler un problème.
Ensuite, je me suis mal exprimé mais mon principal soucis est que je ne sais pas comment faire des appels à un service durant une certaine période à une fréquence donnée. C'est surtout ce point là que je n'arrive pas à implémenter. J'ai trouvé une solution du type

Code :

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

1
2
3
4
5
6
7
8
9
 
long period = 10000;
long startTime = System.currentTimeMillis();
boolean isJobFinished = false;
while (!isJobFinished){
//appel de mes task via ExecutorCompletionService et vérification du résultat. Si lmon résultat est positif j'annule les tâches suivantes et je met à jour ma variable isJobFinished
isJobFinished = (System.currentTimeMillis() - startTime  >= totalTime);
 
}

cette boucle while ne me plait pas beaucoup mais ça fonctionne

Si vous avez une idée plus élégante je suis preneur

[Nico02]

Salut,

En fait je suis pas sûr d'avoir compris ce que tu veux.

Tu veux pouvoir exécuter une tache de façon periodique mais avec uns sorte de timeout sur ton traitement c'est ça ?

[noOneIsInnocent]

Salut Nico

Je veux exécuter une tâche à toutes les fréquences f1 pendant une durée d1.
Si une des tâches aboutit positivement j'annule les tâches suivantes puisque j'aurais obtenu une réponse positive de ma tache( service) .
Le fait d'utiliser le CompletionService avec une tâche qui implémente Callable me permet l’exécution à une certaine fréquence f1 de cette tâche. Et cela me permet de vérifier le résultat de mes tâches

En revanche ce qui me pose problème c'est l'appel aux tâches pendant une durée d1.

Je ne sais pas si c'est plus clair :-)

[Nico02]

Tu peux toujours rajouter une tache qui a pour but de terminer ton scheduler le cas échéant.

Code :

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

1
2
3
4
5
6
7
 
scheduleExecutorService.schedule(new Runnable(){
     public void run(){
       f.cancel( true );
       scheduleExecutorService.shutdown();
     }
},30,SECONDS);

[noOneIsInnocent]

A quoi correspond le f.cancel() ?

[noOneIsInnocent]

désolé pour la question :-)
ok je vais tester avec ta méthode

[Nico02]

Pardon j’étais resté sur ton premier code

C'est pour terminer la tache courante mais je pense que c'est pas nécessaire vu que le shutdown le fait déjà.

[noOneIsInnocent]

merci à tous les deux
@Nico
Ton idée était la bonne et effectivement le f.cancel() est inutile dans notre cas

[noOneIsInnocent]

La solution est dans la javadoc :-)
http://docs.oracle.com/javase/7/docs...orService.html



Here is a class with a method that sets up a ScheduledExecutorService to beep every ten seconds for an hour:

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
 
 import static java.util.concurrent.TimeUnit.*;
 class BeeperControl {
   private final ScheduledExecutorService scheduler =
     Executors.newScheduledThreadPool(1);
 
   public void beepForAnHour() {
     final Runnable beeper = new Runnable() {
       public void run() { System.out.println("beep"); }
     };
     final ScheduledFuture<?> beeperHandle =
       scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS);
     scheduler.schedule(new Runnable() {
       public void run() { beeperHandle.cancel(true); }
     }, 60 * 60, SECONDS);
   }
 }