Threads Exceptions von Threads abfangen im ThreadPool

[redbomber]

Hi zusammen,
brauch mal wieder euren Rat.

Ich habe folgenden Fall bei mir implementiert:

   class MyWorkerClass {

      public doAction_a(){
      try{
         Thread myThread = new MyThread(){
            // run calls runSub()
            runSub() throws Exception{
               //special work
            }
         }
         runThread(myThread);
      }catch{
         handleException_a();
      }
   }

// ... doAction_b(), doAction_c() ...

      public doAction_z(){
      try{
         Thread myThread = new MyThread(){
            // run calls runSub()
            runSub() throws Exception{
              // special work
            }
         }
         runThread(myThread);
      }catch{
         handleException_z();
      }
   }   
   }

D.h. ich habe eine Klasse, die verschiedene Methoden anbietet um spezielle Aufgaben zu erledigen.
Jede Aufgabe wir in einem extra Thread ausgeführt. Die Methode runThread(Thread) startet den jeweiligen Thread.
Man beachte hierbei

handleException_a()

und

handleException_z()

So nun will ich aber das ganze durch einen Thread pool erweitern.
Mein Thread pool erhält die Aufgaben übergeben und kümmert sich um alles weitere.

Nun habe ich aber das Problem dass ich nicht weiss wie ich die Exceptions, die ich hier mit den Methoden

handleException_a()

und

handleException_z()

bearbeite.

   class MyWorkerClass {

      public doAction_a(){
//      try{
         Runnable myWork = new MyWork(){
            runSub() throws Exception{
               //special work
            }
//         }
         submitWork(myThread); //wirft ja keine Exception mehr
//      }catch{
//         handleException_a();
//      }
   }

      public doAction_z(){
//      try{
         Runnable myWork = new MyWork(){
            // run calls runSub()
            runSub() throws Exception{
              // special work
            }
//         }
         submitWork(myThread); //wirft ja keine Exception mehr
     // }catch{
     //    handleException_z();
     // }
   }   
   }

Meine

submitWork(myThread);

nimmt nur ein Runnable entgegen und wirft KEINE Exception. Es übergibt die Aufgabe an meinen ThreadPool.
Die Exception wird wenn dann in der run() Methode meines Runnable geworfen.
Wie soll ich die denn dann abfangen?

Also versteht ihr was mein Problem ist?

Mein ThreadPool weiss ja nichts über die Aufgabe die mein Runnable zu tun hat.
Er startet einfach die Aktion.
Bisher kümmert sich meine Methode

handleException_z()

dass eine Aufgaben-spezifische Aktion bei einer Exception ausgeführt wird.
Mit meiner ThreadPool implementierung weiss ich gerade nicht wie ich das realisieren soll.

 

[truesoul]

Sammel dich nochmal weil ich das z.B nicht verstehe:

Nun habe ich aber das Problem dass ich nicht weiss wie ich die Exceptions, die ich hier mit den Methoden

handleException_a()

und

handleException_z()

bearbeite.

Ja was?

Die Exception wird wenn dann in der run() Methode meines Runnable geworfen.
Wie soll ich die denn dann abfangen?

Mit ein try/catch Block?

Und wenn submitWork(..) eine Exception werfen könnte dann deklariere es doch.
Bzw leite es weiter.

public void submitWork()throws IrgendeineException{
....
}

Somit brauchst du in der Methode kein Try/Catch Block aber dort wo du diese Methode aufrufst.

Ansonsten:
Java ist auch eine Insel – 7 Exceptions

 

[SlaterB]

was macht eigentlich handleException_a() -z, fängt das nur Fehler bei der Thread-Initialisierung ab oder auch für den laufenden Thread?

 public doAction_a(){
      try{
         Thread myThread = new MyThread(){
            // run calls runSub()
            runSub() throws Exception{
               //special work
            }
         }
         runThread(myThread);
      }catch{
         handleException_a();
      }
   }

falls runThread() nämlich einen separaten Thread für myThread startet, dann ist das handleException_a() für den runSub()-Aufruf aus dem Spiel,
oder macht runThread() bisher selber die Arbeit? dann wäre es komisch, Thread-Objekte zu erstellen..




---------

definiere dir Objekte eines Interface

Runner {
    doWork();
    doException();
}

in der Methode doAction_a() wird ein Runner-Objekt erstellt, doWork() erhält //special work + runSub() , doException() erhält handleException_a(),

dann muss irgendwo irgendjemand

Runner r = ..;
try {
  r.doWork();
} catch() {
  r.doException();
}

direkt hintereinander stehen haben, und ob man das dann in einem ThreadPool oder woanders ausführt ist fast egal

soweit eine Bewertung, je nach schon vorhandenen Indirektionen (runSub() ) usw. kann man das vielleicht auch anders machen,
MyThread ist vielleich schon genau Runner usw., man muss sich nicht mit Interfacen überfluten

wichtig aber schon jetzt: try/catch besser nicht für a-z 26x kodieren, das sollte einmal reichen,
ThreadPool dürfte daran wenig ändern

 

[redbomber]

Hi zusammen,
also euch beiden vielen Dank für die Antworten. Ich weiss war leider etwas verwirrend wie ich es erklärt habe...

@truesoul
Also ich habe eine Runnable, welches eine spezifische Aktion ausführt.
Wenn eine Exception in der run() Methode auftritt, wird diese geworfen und bisher durch mein Try-Catch-Block abgefangen. Im catch wird dann wieder ein spezifisches Handling ausgeführt handleException_xyz();

Nun habe ich im Hintergrund einen ThreadPool, welches meine Runnables einfach übergeben bekommt

submitWork(Runnable)

.
Mein submitWork(Runnable) wirft keine Exception, sondern übergibt die Aufgabe nur an den ThreadPool der alles weitere macht...
Mein ThreadPool ist sozusagen unwissend über die Aktion die ein Runnable enthält, sowie dessen spezifischen Excepion Handlings. Ich denke so solls ja sein.

@SlaterB

was macht eigentlich handleException_a() -z, fängt das nur Fehler bei der Thread-Initialisierung ab oder auch für den laufenden Thread?

Also meine handleException_xyz() fängt nur eine Expection während des laufenden Threads ab.

Also mein runThread(myThread); ist kurz wie folgt implementiert:

runThread(myThread){
...
 myThread.start();
...
}

Dient also nur zum starten des Thread (natürlich gibts dann noch Arbeit drumherum, daher in eine Hilfs-Methode verpackt)

definiere dir Objekte eines Interface

Runner {
    doWork();
    doException();
}

Ok, ich glaub jetzt hab ich es kapiert. Das ist genau das womit ich gerade mein Problem hatte.
In meiner Klasse initialisiere ich mein Runnable und gebe an welche Arbeit er machen soll.
Dieses Runnable übergebe ich meinem ThreadPool und der macht alles weitere.
Mir war nicht klar, wie ich auch den Code für den Fall einer Exception an das Runnable übergebe...
Klar, genauso wie ich ihm die Arbeit übergebe! Danke!

wichtig aber schon jetzt: try/catch besser nicht für a-z 26x kodieren, das sollte einmal reichen,
[/code]

Wie meinst denn das?
Also mein Interfcae von Runnable definiert jetzt dann auch eine doException();
Und die werde ich bei jeder Initialisierung von meinen Runnables implementieren.
Ich muss die ja für jedes Runnable implementieren, da jedes Runnable bei mir eine andere Arbet macht und somit auch eine eigene Exception hat.

 

[redbomber]

puh...
um es jetzt noch komplizierter zu machen:

Wenn eine andere Klasse A die Methode doAction_a() der Klasse B aufruft:

public doAction_a() throws Exception{

         Thread myThread = new MyThread(){

            doWork() throws Exception{
               //do work
            }


            doException() throws Exception{
               //do Exception handling
               // or throw Exception
            }
         }
         submitTask(myThread); // übergebe Runnable an ThreadPool
   }

Und dann in meinem ThreadPool irgendwo dann mein Runnable gestartet wird, so wie du es beschrieben hast:

Runner r = ..;
try {
  r.doWork();
} catch() {
  r.doException();
}

Wenn dann also mein r.doException(); eine Exception WIRFT, dann würde diese ja normal an die aufrufende Klasse A weitergeleitet werden.
Nun ja aber nicht mehr, da alles in meinem ThreadPool verkapselt ist und mein ThreadPool ja nichts von der aufrufenden Klasse weiss.
Gibts dafür dann überhaupt noch eine Lösung?

Versteht da noch irgendwer was ich meine?

 

[SlaterB]

> Wie meinst denn das?
so wie geschrieben, es gibt nur irgendwo ein try/catch, welches doException() aufruft, welches vielleicht a-z mal implementiert ist,
aber es braucht nicht 26 try/catches

-----

zwischen Threads Exceptions zu übergeben ist generell schwierig, so ist Fussball, äh Nebenläufigkeit,
das war aber vorher auch schon so falls da wirklich Threads waren, deswegen bezweifle ich auch dass das try/ catch + handleException_a() funktioniert hat,
entweder kam es nie zum tragen oder wenn doch, dann war es kein richtiger Thread,

für Nebenläufigkeit: ob du einen eigenen Thread oder ein Runnable-ähnliches Ding in einen Pool hast macht bei den technischen Möglichkeiten ein bisschen Unterschied, aber fachlich kannst du alles in beiden ausdrücken,
irgendein zuständiges Objekt X wird es wohl geben, das kann sich der Aufrufer merken bevor es in die Nebenläufigkeit geht,
- dies kann einen Zustand haben wie laufend/ Fehler/ ordentlich zu Ende,
- dies kann Listener aufnehmen die bei wichtigten Ereignissen direkt informieren
- es kann synchronisiert gewartet werden
- na mehr hab ich auch nicht zu sagen, ist schon gut was dabei

wo wie was implementiert ist, ist natürlich die Frage, ich erinnere nochmal an die EINE Codestelle

Runner r = ..;
try {
  r.doWork();
} catch() {
  r.doException();
}

solche zentralen aktiven Codes, die für alle Abläufe drankommen, bieten sich dann natürlich auch für Aufrufe a la

Runner r = ..;
try {
  r.doWork();
} catch() {
  r.doException();
  r.setLevel(Level.Error);
  r.informListener();
}

an, wobei das natürlich auch intern passieren kann,
und sowas wie setLevel() sollte natürlich keine Interface-Methode sein die 26x implementiert wird, sondern wieder nur einmal,
z.B. in einer Basisklasse, MyThread klang ja stark nach Klasse statt Interface