Propager une exception

Version imprimable

Hello,

Je voudrais propager une exception, comme cela:

Code:

throw new NagiosException("Unable to call Method "+functionName+":"+e.getMessage());

Seulement, je voudrais faire cela dans une méthode run() de Runnable, qui n'est pas prévue pour propager d'exception... Comment faire?

Ce que je voudrais:
Code:

1 2 3 4 5 6 7 8 // Create runnable final Runnable r = new Runnable(){ @Override public void run() throws NagiosException { // génération de l'exception } };
Y a-t-il un moyen détourné?

Merci d'avance,
A+

10/10/2007, 15h36
adiGuba

Salut,

Tu peux utiliser une RuntimeException... mais dans ce cas rien ne t'obligera à la traiter (et le thread sera interrompu).

Quel est le contexte d'utilisation ?

a++

J'utilise un Timer:
Code:

1 2 3 4 5 6 7 8 Timer tm = new Timer(); tm.schedule(new TimerTask(){ @Override public void run() { t = new Thread(r); t.start(); } }, startTime, freq);
Et c'est dans le Runnable r que cette exception peut être levée.

P.S. J'ai mis seulement une partie de mon code, il est indispensable que je fasse comme cela, même si dans ce cas ça peut parraitre étrange...

Merci, si tu as une idée...

A+

Si tu utilises une RuntimeException cela arrêtera le thread "violemment"...

Sinon ce que tu peux faire c'est de gérer cela au niveau de ton Runtime :

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
abstract class AbstractRunnable implements Runnable {
 
	/**
         * On utilise une méthode abstraite qui remplacera run(),
         * et qui permet de remonter n'importe quelle exception :
         * @throws Throwable
         */
	public abstract void runOrThrow() throws Throwable;
 
	/** On utilise un attribut pour stocker les eventuelles exceptions : */
	private Throwable throwable = null;
 
	/**
         * On implémente run() afin qu'elle appelle runOrThrow() et conserve
         * les éventuelles exceptions...
         */
	public final void run() {
		try {
			runOrThrow();
		} catch (Throwable t) {
			this.throwable = t;
		}
	}
 
	// + des méthodes utilitaires pour déterminer s'il y a eu une exception ou pas :
 
	public boolean isValid() {
		return this.throwable==null;
	}
 
	public Throwable getThrowable() {
		return this.throwable;
	}
}

:arrow: Tu implémentes runOrThorw() au lieu de run(), et à la fin tu peux récupérer les éventuelles exceptions via getThrowable()...

a++