Discussion :

[pjmorce]

Bonjour

J'ai une application ayant une classe qui a une méthode qui exécute quelque chose qui peut prendre énormément de temps et que retourne un boolean comme résultat.

...
boolean bResult = false;
...
bResult = Report.execute(params);
...

if(bResult) {
...
}

J'aimerai faire en sorte que quand plus de 10 secondes passent, un TimeOutException soit généré.

Pouvez vous m'aider?

merci

[tchize_]

c'est dans la méthode en question que tu devra faire cette gestion, il faudra qu'elle controle régulioèrement depuis combien de temps elle tourne et lance éventuellement l'exception.

[pjmorce]

Oui, c'est ce que j'aurais voulu faire mais.... la méthode en cause est une méthode qui ne m'appartient pas et donc je ne peut pas la modifier...

J'ai réussi à faire en sorte qu'un timeout soit généré si la méthode prends plus que 10000 millisecondes, mais en revanche je ne vois pas comment récupérer la valeur retournée par la méthode....

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
 
 
...
boolean bResult = false;
int iTimeout = 10000;
final List<String> taskParameters = params;
try {
 
    // create new task
    theTask = new FutureTask<Object>(new Runnable() {
         public void run() {    
           try {
             boolean bResultTask = Report.execute(params);
           } catch(Exception e) {
              ...
           }
         }
    }, null);
 
    // start task in a new thread
    new Thread(theTask).start();
 
    // wait for the execution to finish, timeout after 10 secs       theTask.get(iTimeout, TimeUnit.MILLISECONDS);
 
 
} catch (TimeoutException e) {
       System.out.println("TimeoutException");
       throw new TimeoutException();
}
...
 
if(bResult) {
...
}

c'est dans la méthode en question que tu devra faire cette gestion, il faudra qu'elle controle régulioèrement depuis combien de temps elle tourne et lance éventuellement l'exception.

[Grimly_old]

Bonsoir,

Les Future sont à utiliser avec les Schedulers.

A plus

[pjmorce]

Bonjour

Donc, les Future ne sont pas à utiliser pour implémenter le timeout prétendu?

Comment puis-je faire alors?

(je rappelle que je veux être capable de lancer l'exécution d'une méthode que je ne peux pas modifier et qui retourne une valeur. Dans le cas ou X secondes passent sans réponses, alors lancer un timeout. Sinon, obtenir la valeur retournée par la méthode...)

merci

Bonsoir,

Les Future sont à utiliser avec les Schedulers.

A plus

[tchize_]

il faut d'abord que tu sois bien conscient que si tu ne peux pas modifier la méthode, quoi qu'il arrive elle devra s'exécuter jusqu'au bout. Même si tu joue avec des threads pour continuer ton travail sans attendre, la méthode continuera à manger ton processeur jusqu'à ce qu'elle aie fini ou que ton programme quitte.

Ceci étant dit, et en supposant que tu veux juste continuer le reste du travail (quitte à laisser cette méthode travailler)


imaginons que tu doive appeler donc "int execute(List<String>params)" sur une instance de la classe Report (ainsi on reste général)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
public class Tache extends Thread{
     Report report;
     List<String> params;
     int result;
     public Tache(Report report, List<String> params){
         this.report = report;
         this.params=params;
     }
     public void run(){   result = report.execute(params);}
}

puis dans le code

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
 
 
public int maMethode(Report report, List<String> params) throws MonTimeoutException{
     Tache tache = new Tache(report,params);
     tache.start();
     try{
         tache.join(10000); // 10 secondes
         if (tache.isDone())
             return tache.result;
         else
             throw new MonTimeoutException("Pas fini dans les temps (10 secondes)");
     } catch (InterruptedException e){
         throw new MonTimeoutException("interrompu");
     }
}

[Rei Ichido]

Ensuite il y a aussi la possibilité de modifier ta méthode.

Si elle prend très longtemps parce qu'elle boucle sur un très grand nombre d'éléments, mais que chaque itération prend un temps raisonnable, tu peux initialiser une variable temps au début, et à la fin de chaque itération regarder le temps écoulé ; et lancer une exception si le temps est écoulé.

[Grimly_old]

Bonjour,

J'aurais plutôt laisser le Scheduler faire le travail lui même.

Le travail à réaliser :

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 Travail implements Callable<Boolean> {
    private Boolean resultat = null;
 
    public void run() {
        //Ici tout le code à générer.
        //Le résultat est à mettre dans "resultat" quand c'est fini
    }
 
    public Boolean call() throws Exception {
        if (resultat == null) // J'ai triché un peu, j'ai utilisé résultat comme un objet qui peux être à "null"
            throw new PasDeResultat();
        return resultat;
    }
}

La vérification du travail et traitement du résultat :

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
public class VerifTravail implements Runnable {
    private final Travail travail;
    public VerifTravail(Travail travail) {
        this.travail = travail;
    }
 
    public void run() {
        try {
            boolean resultat = travail.call();
            // traitement résultat ici.
        } catch (Exception e) {
            // traitement timeout ici.
        }
    }
}

et enfin lorsque tu veux lancer le traitement :

Code :

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

1
2
3
4
5
6
7
8
9
10
public class Lanceur {
 
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(4);
 
    public void lancer(Report report, List<String> params) {
        Travail travail = new Travail(report, params);
        scheduler.execute(travail); // On execute le travail
        scheduler.schedule(new VerifTravail(travail), 10, TimeUnit.SECONDS); // Et on vérifie dans 10 secondes s'il est fait.
    }
}

C'est (trop ?) lourd pour une simple exécution, mais pour un travail en continu sur une masse de données, c'est adapté.

Après, je ne connais pas vraiment les besoins de ton projet. Si ta méthode est appelée occasionnellement sans parallélisme (pas plus d'une fois en 10 secondes), ne suis pas la voie que je viens de donner.