Gestion d'un timeout

Version imprimable

20/04/2010, 11h19
pjmorce

Gestion d'un timeout

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.

Citation:

...
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
20/04/2010, 13h21
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.

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:

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) { ... }
Citation:

Envoyé par 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.

21/04/2010, 04h32
Grimly_old

Bonsoir,

Les Future sont à utiliser avec les Schedulers.

A plus ;)
21/04/2010, 07h53
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

Citation:

Envoyé par Grimly

Bonsoir,

Les Future sont à utiliser avec les Schedulers.

A plus ;)

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:

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:

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"); } }

21/04/2010, 11h14
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é.

Bonjour,

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

Le travail à réaliser :

Code:

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:

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:

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.