# Exception aus Thread werfen



## artus1977 (3. Aug 2010)

Hallo zusammen

Ich stehe vor dem Problem, dass ich gerne Exceptions aus einem Thread werfen möchte.


```
class Arbeit extends Thread{

void run() throws Exception{

sysout("Hallo");

}

}
```

Blos geht das "throws Exception" nicht.

Danke für jeden Tip ;-)


----------



## Gast2 (3. Aug 2010)

Genau, so geht das nicht.
Du musst 
	
	
	
	





```
public void run()
```
 überschreiben und die wirft nunmal keine Exception 

Weshalb wollst du den in der run() ne exception werfen? Bzw. wer soll die fangen?


----------



## artus1977 (3. Aug 2010)

Hi EikeB

In meinem main möchte ich folgenden Code ausführen.


```
ScheduleClassManager mySCM = new ScheduleClassManager("com.prg.BusinessLogik","07:00","18:36");
			
mySCM.start();
```

Dabei geht es darum, dass ich irgend eine Klasse übergeben kann, wo ich Timer gesteuert sagen kann, wann was ausgeführt werden soll. Also als Beipspiel wird von 07:00 bis 18:36 etwas ausgeführt, danach geht meine Anwendung schlafen und erwacht erst wieder um 07:00.

Jetzt würde ich natürlich gerne die Exception aus meinem Thread abfangen



```
ScheduleClassManager mySCM = new ScheduleClassManager("com.prg.BusinessLogik","07:00","18:36");
	
try {		
mySCM.start();
}
catch (Exception e){
System.out.println("EXCEPTION ABGEFANGEN :-) ");
}
```

Hoffe das sagt dir jetzt mehr.......ist nicht einfach so einen ersten Forumseintrag zu erstellen ;-)


----------



## Michael... (3. Aug 2010)

Geht nicht, da Du ja mit start() einen neuen Thread erzeugst, der "unabhängig" vom aufrufenden Thread läuft. Die Exception kannst Du nur innerhalb des Threads, in dem Sie auftreten kann auch abfangen.


----------



## SlaterB (3. Aug 2010)

das widerspricht nach wie vor dem Wesen von Threads,
nach start() bleibt der Aufrufer nicht stehen und wartet vielleicht auf einen Rückgabewert, sondern läuft weiter,
bis nach 3 Min. die Exception kommt ist der Aufrufer längst nicht mehr im try/catch-Block, 

synchron vs asynchron,
wenn du mit jemanden am Telefon sprichst, kannst du direkt auf eine Antwort warten,

schickst du aber einen Brief oder eine Email, so liest das Gegenüber diese Nachricht erst viel später in einem anderen Kontext,
du selber sitzt dann (wahrscheinlich) nicht mehr vorm Email-Account oder mit Stift am Schreibtisch, das Empfangen einer Nachricht ist ein vollkommen unabhängiger anderer Vorgang


----------



## Tomate_Salat (3. Aug 2010)

dann mach doch lieber soetwas:

```
// Arbeit.java
public class Arbeit
	extends Thread
{
	private IExceptionHandler handler;
	
	public Arbeit(IExceptionHandler handler)
	{
		this.handler	= handler;
	}
	
	@Override
	public void run()
	{
		try
		{
			Thread.sleep(1000);
		}
		catch(InterruptedException e)
		{
			handler.catchException(e);
		}
	}
	
	public static void main(String[] args)
	{
		IExceptionHandler handler	= new IExceptionHandler()
		{
			
			@Override
			public void catchException(Exception e)
			{
				System.out.println("EXCEPTION ABGEFANGEN :-) ");
			}
		};
		
		new Arbeit(handler).start();
	}
}

// IException.java
public interface IExceptionHandler
{
	public void catchException(Exception e);
}
```

kannst das Interface beliebig erweitern und somit auch Exceptions unterschiedlich behandeln oder eben eine Standartvariante festlegen...es erlaubt dir somit ein besseres Exceptionhandling, dass du ggf auch austauschen kannst (z.B. könntest du einen Debugmodus einbauen, der die Exceptions anderster behandelt als der in der Release etc)

MFG

Tomate_Salat


----------



## Murray (3. Aug 2010)

Oder Du verpasst dem Thread einen eigenen UncaughtExceptionHandler


----------



## Volvagia (3. Aug 2010)

Kann man nicht einfach eine Callable verwenden? Da bekommt man beim get() vom Future eine eventuelle Exception geschmissen.


----------



## hemeroc (4. Aug 2010)

Das mit dem UncoughtExceptionHandler geht zwar prinzipiell allerdings hast du keine Ahnung was die Exception wirft bzw könnte es mühsamer sein das herauszufinden und is in dem Fall eher unsauber.
Die Lösung von Tomate_Salat kommt meiner Meinung nach dem was hier denke ich die allgemeine "Best Practice" wäre recht nahe, nämlich eine Callback-Funktion.

Gib deinem Thread eine Instanz der Klasse mit die ihn startet und generiere in der Klasse die ihn startet eine Callback-Funktion.
Behandle die Exception soweit als möglich in deinem Thread.
Rufe dann die Callback-Funktion auf um dem "Ersteller" eine Rückmeldung zu geben.
Hier gibts auch einiges was dir das Leben erleichtern kann Stichwort: Listener, ObserverPattern
LG Hemeroc


----------



## Murray (4. Aug 2010)

@Hemeroc: wenn es um allgemeines Feedback oder auch nur eine typsichere, spezifischere Behandlung bestimmter Exception-Typen geht, bin ich bei Dir; hier wäre eine Callback-Funktion (bes. in Form von Standard-Patterns wie Event/Listener oder Observer/Observable) ein guter Ansatz.
Wenn die Callback-Funktion aber nichts anderes macht als unterschiedlos alle Exceptions zu akzeptieren, dann macht sie eigentlich nichts anderes als der UncaughtExceptionHandler. Insofern würde ich anstelle des Callbacks mit der einfachen catchException-Methode doch eher den Standard-Mechanismus verwenden; was soll daran denn unsauber sein?


----------



## alderwaran (4. Aug 2010)

Murray hat gesagt.:


> hier wäre eine Callback-Funktion (bes. in Form von Standard-Patterns wie Event/Listener oder Observer/Observable) ein guter Ansatz.



daran dachte ich zuerst auch.


```
import java.util.Observable;
import java.util.Observer;

public class Main implements Observer {

    public Main() {
        Arbeit arbeit = new Arbeit();
        arbeit.addObserver(this);
        arbeit.run();
    }

    public static void main(String[] args) {
        Main m = new Main();
    }

    public void update(Observable o, Object arg) {
        Exception e = (Exception) arg;
        System.out.println(e.getMessage());
    }
}

class Arbeit extends Observable implements Runnable {

    public void run() {
        try {
            Thread.sleep(50000);
        } catch (InterruptedException e) {
            super.setChanged();
            super.notifyObservers(e);
        }
    }
}
```


----------



## artus1977 (4. Aug 2010)

Hallo zusammen

Kurzes Lebenszeichen vom Auslöser ;-)

Zuerstmal danke für eure Beiträge und Hilfe!!! Ich muss mich aber noch aus dem Sammelsurium von Möglichkeiten durcharbeiten.
... und versuchen zu Verstehen ;-) 

Nach der bildlichen Darstellung der Theorie von SlaterB, muss ich mir eh überlegen, ob ich so auf dem richtigen Weg bin.


----------



## SlaterB (4. Aug 2010)

vielleicht brauchst du keinen Thread sondern einen stinknormalen Methodenaufruf,
da gibts Rückgabewert und Exceptions, der Aufrufer wartet solange


----------



## Tomate_Salat (4. Aug 2010)

Dann schreib mal genauer, was du vorhast, dann können wir dir eventuell sagen ob du auf dem richtigen weg bist


----------



## hemeroc (4. Aug 2010)

Murray hat gesagt.:


> @Hemeroc: wenn es um allgemeines Feedback oder auch nur eine typsichere, spezifischere Behandlung bestimmter Exception-Typen geht, bin ich bei Dir; hier wäre eine Callback-Funktion (bes. in Form von Standard-Patterns wie Event/Listener oder Observer/Observable) ein guter Ansatz.
> Wenn die Callback-Funktion aber nichts anderes macht als unterschiedlos alle Exceptions zu akzeptieren, dann macht sie eigentlich nichts anderes als der UncaughtExceptionHandler. Insofern würde ich anstelle des Callbacks mit der einfachen catchException-Methode doch eher den Standard-Mechanismus verwenden; was soll daran denn unsauber sein?



Sry sry sry,... -_- war mein Fehler,... ich hab irgendwie DefaultUncaughtExceptionHandler gelesen frag mich bitte ned warum und den einen für möglicherweise n Threads zu verwenden is unsauber. So is der Ansatz mit einem UncaughtExceptionHandler für den einen Thread von dir eh gut.
Nochmal sry.
LG Hemeroc


----------

