Hallo zusammen,

ich habe angefangen, mich mit Threads zu beschäftigen und erste Versuche unternommen, Threads in meine Anwendung einzubauen. Ein Problem, das ich dabei habe, sind Exceptions. In meiner Anwendung verwende ich EurekaLog und möchte, dass der Callstack bei Exceptions im Bugreport enthalten ist. Daher muss ich die Exception irgendwie nach außen an den aufrufenden bzw. an den Main-Thread weiterleiten.

Ich habe versucht, die Exception im Thread abzufangen und mit einem Event (OnError) an den Main-Thread weiterzuleiten (TThreadEx ist eine von TThread abgeleitete Klasse von EurekaLog):

zusammenfalten · markieren

Delphi-Quellcode:

TThreadErrorEvent = procedure(const E: Exception) of object;

TBaseThread = class(TThreadEx)
  strict private
    FOnError: TThreadErrorEvent;
    procedure DoOnError(const E: Exception);
  strict protected
    procedure Execute; override; final;
    procedure Run; virtual; abstract;
  public
    constructor Create(CreateSuspended: Boolean);
    property OnError: TThreadErrorEvent read FOnError write FOnError;
  end;

implementation

constructor TBaseThread.Create(CreateSuspended: Boolean);
begin
  inherited Create(CreateSuspended);
end;

procedure TBaseThread.DoOnError(const E: Exception);
var
  existingException: Exception;
begin
  if (@FOnError = nil) OR (E = nil) then
    Exit;

  existingException := AcquireExceptionObject;

  Synchronize(procedure
              begin
                try
                  FOnError(existingException);
                except
                  on NewException: Exception do
                  begin
                    if NewException <> existingException then
                      E.Free; // exception has been wrapped or another exception has been raised
                    raise;
                  end;
                end;
                // exception has not been re-raised and not been wrapped
                E.Free;
              end);
end;

procedure TBaseThread.Execute;
begin
  try
    inherited;
    Run;
  except
    on E: Exception do
      DoOnError(E);
  end;
end;

Mein Problem ist in der Prozedur DoOnError. Ich habe festgestellt, dass ein Memory-Leak entsteht, wenn ich E.Free nicht aufrufe (ReleaseExceptionObject hat nichts gebracht). Den Code finde ich aber ziemlich hässlich und ich könnte mir vorstellen, dass es eine schönere Lösung gibt. Meine Idee ist, in dem Event-Handler FOnError, welcher im Moment im wegen dem Synchronize im Main-Thread ausgeführt wird, die Exceptions zu behandeln, also z. B. einfach weiterzuleiten oder mit Exception.RaiseOuterException eine neue Exception herum zu packen oder die "verschwinden" zu lassen (nachdem man entsprechend darauf reagiert hat).
Eine Lösung wäre vllt., das AcquireExceptionObject nicht im DoOnError zu machen sondern jeweils im Event-Handler, das man für FOnError setzt. Das möchte ich jedoch vermeiden, weil ich es sonst jedes Mal neu implementieren muss.


Und noch eine weitere Frage: Ich rufe das Event FOnError durch das Synchronize im Kontext des Main-Threads auf. Gibt es eine Möglichkeit, dies im Kontext eines anderen Threads auszuführen? Wenn ich beispielsweise aus dem Main-Thread einen Thread A starte, welcher wiederum einen Thread B startet, dann möchte ich, dass Thread B einen aufgetretenen Fehler an Thread A schickt und nicht an den Main-Thread.

Ich bin für jede Hilfe dankbar

Wenn du die Exception im Execute nicht abfängst, dann kannst du sowas machen:

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit6;

interface

uses
  System.SysUtils, System.Classes,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;

type
  TMyThread = class(TThread)

  protected
    procedure Execute; override;
  end;

  TForm6 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    FThread: TMyThread;
    procedure OnMyThreadTerminate(Sender: TObject);
  public
    { Public declarations }
  end;

var
  Form6: TForm6;

implementation

{$R *.dfm}


procedure TForm6.Button1Click(Sender: TObject);
begin
  FThread := TMyThread.Create;
  FThread.OnTerminate := OnMyThreadTerminate;
  FThread.FreeOnTerminate := True;
end;

{ TMyThread }

procedure TMyThread.Execute;
var
  a, b: Integer;
begin
  inherited;
  b := 0;
  a := a div b;
end;

procedure TForm6.OnMyThreadTerminate(Sender: TObject);
var
  ThreadException: Exception;
begin
  // das hier wird im Kontext des Main-Threads automatisch aufgerufen.
  if Assigned(Sender) and (Sender is TThread) then
  begin
    ThreadException := Exception(TThread(Sender).FatalException);
    if Assigned(ThreadException) then
      ShowMessage(ThreadException.Classname + ' : ' + ThreadException.Message);
  end;
end;

end.

Fakt ist: ReleaseExceptionObject() tut entgegen der Doku (unter Windows) nichts. Der Code ist vorhanden, aber aus unerklärlichen Gründen von einer leeren Methode verdeckt.

Siehe:
http://www.delphipraxis.net/192895-a...ionobject.html

Man muss die explizit mit AcquireExceptionObject() geholte Exception auch explizit wieder freigeben.

Zitat:

Wenn du die Exception im Execute nicht abfängst, dann kannst du sowas machen [...]

Dann habe ich aber zwei Probleme: Zum einen muss ich den Code für den OnTerminate-Eventhandler mehrmals duplizieren, wenn ich Exceptions aus Threads immer so behandeln möchte und zweitens kann ich FatalException nicht erneut auslösen. Da kommen dann Anwendungsfehler, was wahrscheinlich daran liegt, dass FatalException eine Property vom Thread ist, der zwischendurch vllt. mal freigegeben wird. Ob da dann der komplette Callstack an der Exception noch dran hängt, konnte ich deshalb auch nicht überprüfen.

Zitat:

Fakt ist: ReleaseExceptionObject() tut entgegen der Doku (unter Windows) nichts. Der Code ist vorhanden, aber aus unerklärlichen Gründen von einer leeren Methode verdeckt.

Danke, das erklärt meine erfolglosen Versuche mit ReleaseExceptionObject.

Zitat:

E.Free

DU, darfst niemals eine Exception freigeben, welche noch mit dem Exception-Handling verbunden ist
Wenn, dann gäbe es dafür ReleaseExceptionObject, aber das macht aktuell intern eigentlich garnichts. (leere Prozedur)

Mit AcquireExceptionObject kannst du das Exception-Objekt abhängen und den Besitz übernehmen.

markieren

Delphi-Quellcode:

try
  ...
except
  MyException := AcquireExceptionObject as Exception;
  //MyExceptAddr := ExceptAddr;
end;

Das kannst du dann später auch in einen anderen thread mitnehmen und da machen was du willst.
Hier am Ende natürlich nicht das MyException.Free; vergessen. (außer du löst die Exception erneut aus -> raise)

Mit raise MyException;
oder raise MyException at MyExceptAddr;
kkönntest du die Exception irgendwo erneut auslösen, auch in einem anderen Thread.


PS: TThread hat ein Property FatalException, welches man ausschließlich im OnTerminate-Event benutzen kann.
Wenn du diese Exception aber aus dieser Methode mitnehmen/weiterreichen willst, dann mußt du sie kopieren. (Exception macht anschließend immer ein Free auf dieses Objekt)
MyException := Exception.Create(FatalException.Message); und anschließend raise MyException; ,
MyException := ExceptClass(FatalException.ClassType).Create(FatalException.Message); inkl. der ursprünglichen Exception-Klasse
oder MyExceptionMessage := FatalException.Message; und raise Exception.Create(MyExceptionMessage);


Delphi fängt im TThread-Execute, im Synchronize und in VCL-Events alle Exception ab.
Allerdings werden ausschließlich Exceptions des Hauptthreads automatisch angezeigt. (Exception-Fenster)
und die in Threads gehen ins Nirvana, wenn sie niemand behandelt.

Würde eine Exception bis zum Windows durchrauschen, ohne abgefangen zu werden, dann würde sofort der gesamte Prozess abgeschossen. (Programm beendet)
Darum macht Delphi das.

Zitat von himitsu:

Zitat:

E.Free

DU, darfst niemals eine Exception freigeben, welche noch mit dem Exception-Handling verbunden ist
Wenn, dann gäbe es dafür ReleaseExceptionObject, aber das macht aktuell intern eigentlich garnichts. (leere Prozedur)

Mit AcquireExceptionObject kannst du das Exception-Objekt abhängen und den Besitz übernehmen.

markieren

Delphi-Quellcode:

try
  ...
except
  MyException := AcquireExceptionObject as Exception;
  //MyExceptAddr := ExceptAddr;
end;

Das kannst du dann später auch in einen anderen thread mitnehmen und da machen was du willst.
Hier am Ende natürlich nicht das MyException.Free; vergessen. (außer du löst die Exception erneut aus -> raise)

Mit raise MyException;
oder raise MyException at MyExceptAddr;
kkönntest du die Exception irgendwo erneut auslösen, auch in einem anderen Thread.

PS: TThread hat ein Property FatalException, welches man ausschließlich im OnTerminate-Event benutzen kann.
Wenn du diese Exception aber aus dieser Methode mitnehmen/weiterreichen willst, dann mußt du sie kopieren. (Exception macht anschließend immer ein Free auf dieses Objekt)
MyException := Exception.Create(FatalException.Message); und anschließend raise MyException; ,
MyException := ExceptClass(FatalException.ClassType).Create(FatalException.Message); inkl. der ursprünglichen Exception-Klasse
oder MyExceptionMessage := FatalException.Message; und raise Exception.Create(MyExceptionMessage);

Delphi fängt im TThread-Execute, im Synchronize und in VCL-Events alle Exception ab.
Allerdings werden ausschließlich Exceptions des Hauptthreads automatisch angezeigt. (Exception-Fenster)
und die in Threads gehen ins Nirvana, wenn sie niemand behandelt.

Würde eine Exception bis zum Windows durchrauschen, ohne abgefangen zu werden, dann würde sofort der gesamte Prozess abgeschossen. (Programm beendet)
Darum macht Delphi das.

Hallo himitsu,

danke für deine ausführliche Erklärung. Ich hätte dazu jedoch noch ein paar Fragen:

Zitat:

DU, darfst niemals eine Exception freigeben, welche noch mit dem Exception-Handling verbunden ist

Mache ich das in meinem Code? Ich habe mir mit AcquireExceptionObject die Exception geholt. Im except-Block, der sich in der Prozedur im Synchronize befindet, gebe ich die Exception nur dann frei, wenn sie im OnError-Eventhandler nicht geraised wurde.
Unsicher bin ich mir, wie Delphi sich verhält, wenn ich im Eventhandler Exception.RaiseOuterException verwende. Dann wird um die Exception, deren Kontrolle ich mir mit AcquireExceptionObject geholt habe, als InnerException einer neuen Exception angehängt, richtig? Nimmt sich Delphi in diesem Fall die Kontrolle zurück oder muss ich die Exception selbst wieder freigeben, so wie ich es mache, wenn NewException <> existingException?

Zitat:

Delphi fängt im TThread-Execute, im Synchronize und in VCL-Events alle Exception ab.

Das habe ich getestet und kann ich nicht bestätigen. Wenn ich z. B. folgenden Code habe:

markieren

Delphi-Quellcode:

try
  Synchronize(procedure
              begin
                raise Exception.Create('Test');
              end);
except
  // Exception behandeln
end;

dann bekomme ich im except-Block die Exception, die ich innen ausgelöst habe. Das ist auch etwas, was ich an Threads noch nicht verstanden habe: Wenn ich den Code so ausführe, wird die Exception dann zweimal ausgelöst, also einmal im Main-Thread und einem im Unter-Thread? Wenn ich den Debugger benutze, dann sieht es fast danach aus.

Zitat:

PS: TThread hat ein Property FatalException, welches man ausschließlich im OnTerminate-Event benutzen kann.
Wenn du diese Exception aber aus dieser Methode mitnehmen/weiterreichen willst, dann mußt du sie kopieren. (Exception macht anschließend immer ein Free auf dieses Objekt)
MyException := Exception.Create(FatalException.Message); und anschließend raise MyException; ,
MyException := ExceptClass(FatalException.ClassType).Create(FatalException.Message); inkl. der ursprünglichen Exception-Klasse
oder MyExceptionMessage := FatalException.Message; und raise Exception.Create(MyExceptionMessage);

Ich denke, dass das leider keine praktische Implementierung für mich ist, da ich in bei einem Fehlerbericht von EurekaLog den Callstack der ursprünglichen Exception sehen möchte, was vor allem dann wichtig ist, wenn eine unerwartete Exception auftritt, deren Ursprung ich finden möchte. Wenn ich nun die Property FatalException verwende, um mir daraus eine neue Exception zu generieren, dann sind diese Informationen (soweit ich weiß) verloren.

Und noch eine letzte Frage: Das OnTerminate-Event wird immer im Kontext des Threads ausgeführt, aus dem der Unter-Thread gestartet wurde, oder? Besteht die Möglichkeit, ein Event so wie das OnError-Event aus meinem ersten Beitrag im Kontext eines anderen Threads (nicht der Main-Thread!) auszuführen? Also so etwas wie Synchronize und Queue, aber nicht für den Main-Thread. Oder ist es eine schlechte Architektur, wenn man versucht, etwas mit einem anderen als dem Main-Thread zu synchronisieren?


Da ich gerade ziemlich viele offene Fragen bzgl. Threads habe: Kann jemand ein Buch empfehlen, das sich vorwiegend mit Threads in Delphi beschäftigt?