ExternalThread Delphi 2009

[schmitzpm]

Hi,

ich weiß, dieses Problem wurde bereits von jemand anderem mal gepostet, aber dessen eigene Lösung bringt mich nicht weiter da ich bereits mit inherited arbeite.


Ist jemand anders vielleicht auch schon über ein TThread Problem in D2009 gestolpert? Ich verwende eine eigene Thread Klasse die von TThread ableitet ist.

Wenn ich nun FFileChanged.Terminate aufrufe, bekomm ich die neue Exception SThreadExternalTerminate aus Classes.pas um die Ohren gehauen ("Ein extern ersteller Thread kann nicht beendet werden").

Das liegt am Property ExternalThread - welches aber read-only ist.

Selbst wenn ich mit folgendem Code

Delphi-Quellcode:

constructor TThreadFileChanged.Create(AWatchFile: String);
begin
   inherited Create(False);
   WatchFile:= AWatchFile;
   FreeOnTerminate := True;
   Priority := tpIdle
end;

Wenn ich den neuen Thread benutze frage ich extra nach ExternalThread ab.
Auch wenn der Wert True ist wird dies ignoriert und Terminate (dann mit Fehler) durchlaufen.

Delphi-Quellcode:

if FFileChanged.ExternalThread = True
then begin
   Exit;
end;

FFileChanged.Terminate;

Ich verwende den Thread in einem Editor mit mehreren Tab-Reitern um zu prüfen ob sich eine Datei durch ein anderes Programm verändert hat.
Beim Wechsel des Tabs schalte ich den Thread aus und danach wieder an.
Erst nach mehrfachem Hin-und Herschalten tritt das Problem dann auf.


Hat jemand eine Idee?

[samso]

Also für mich hört sich das nach einem Zugriff auf ein bereits freigegebenes Objekt an. Der Fehler sitzt vermutlich ausserhalb des Threads. Beim Tab-Wechsel wird ja wahrscheinlich FFileChanged.Terminate aufgerufen. Danach ist der Inhalt von FFileChanged ungültig und darf nicht mehr angefasst werden, da sich der Thread ja selbst freigibt. Am besten also vielleicht eine solche Konstruktion benutzen:

Delphi-Quellcode:

FFileChanged.Terminate;
FFileChanged := nil;

Bzw.

Delphi-Quellcode:

//Alten Thread beenden
FFileChanged.Terminate;
//Einen neuen Thread starten
FFileChanged := TThreadFileChanged.Create(AnotherWatchFile);

Vielleicht einfach mal den kompletten Quelltext des TThreadFileChanged posten?

[schmitzpm]

Hier mal der Quellcode der eigentlichen Unit:

Delphi-Quellcode:

unit FileChanged;

interface

uses
   Classes,Windows,Dialogs;

type
   TThreadFileChanged = class(TThread)
   private
      ChangeHandle: THandle;
      WatchFile:    String;
      { Private-Deklarationen }
   protected
      procedure Execute; override;
      procedure AskAfterFileChanged;
   public
      constructor Create(AWatchFile: String);
      destructor Destroy;
   end;

implementation

uses MainForm, SysUtils, MySynEdit;

{ TThreadFileChanged }

procedure TThreadFileChanged.AskAfterFileChanged;
begin
   if f_MainForm.Editor.HasFileChanged = true
   then
      f_MainForm.FileHasChanged;
end;

constructor TThreadFileChanged.Create(AWatchFile: String);
begin
   inherited Create(False);
   WatchFile:= AWatchFile;
   FreeOnTerminate := True;
  Priority := tpIdle
end;

destructor TThreadFileChanged.Destroy;
begin
  if Self.ExternalThread = True
  then begin
    Exit;
  end;

   if ChangeHandle <> 0
   then
      FindCloseChangeNotification(ChangeHandle);
   inherited Destroy;
end;

procedure TThreadFileChanged.Execute;
begin
   { Thread-Code hier einfügen }
   ChangeHandle := FindFirstChangeNotification(PChar(WatchFile),False,FILE_NOTIFY_CHANGE_LAST_WRITE);
   if ChangeHandle <> INVALID_HANDLE_VALUE
   then
      // Hier wird im 500 ms-Takt die Datei auf Änderungen überprüft.
      while True do begin
         if WaitForSingleObject(ChangeHandle,500) = WAIT_OBJECT_0
         then begin
            Synchronize(AskAfterFileChanged);
            FindNextChangeNotification(ChangeHandle);
            if Terminated then Break;
         end;
      end;
end;

end.

Hier noch einige Proceduren die den Thread starten und stoppen:

Delphi-Quellcode:

procedure Tf_MainForm.StartFileChangedThread;
begin
  // Thread zur Verzeichnisüberprüfung starten
  if SysUtils.ExtractFileDir(Editor.FileName) <> ''
  then
    FFileChanged := TThreadFileChanged.Create(SysUtils.ExtractFileDir(Editor.FileName));
end;


procedure Tf_MainForm.StopFileChangedThread;
begin
  // Thread für Dateiüberwachung ausschalten
  if FFileChanged <> nil then
  begin
    // Nur wenn kein external Thread dann stoppen.
    if FFileChanged.ExternalThread = True
    then begin
      Exit;
    end;

    FFileChanged.Terminate;
    FFileChanged := nil;
  end;
end;

Die beiden Proceduren StartFileChangedThread und StopFileChangedThread werden immer innerhalb eines Vorgans aufgerufen.
Natürlich wird erst der Thread gestoppt, die Tabseite geweichselt oder die Datei abgespeichert und danach der Thread wieder gestartet.
Die Aufrufe finden jeweils über die beiden Proceduren statt.

Vielleicht hat ja jemand eine Idee.
Danke

[samso]

Mir fällt erstmal auf, dass bei destroy das override fehlt. Also probiere doch mal.

destructor Destroy; override; Vielleicht war es das ja schon?

[samso]

Dann würde ich die Execute-Schleife noch etwas verändern:

Delphi-Quellcode:

while not Terminated do begin 
  if WaitForSingleObject(ChangeHandle,500) = WAIT_OBJECT_0 
  then begin 
    Synchronize(AskAfterFileChanged); 
    FindNextChangeNotification(ChangeHandle); 
  end; 
end;

Denn auch wenn WaitForSingleObject auf einen Timeout gelaufen ist, sollte Terminated abgefragt werden.

[schmitzpm]

Hallo samso,

habe deine Änderungen eingebaut. Aufgrund der Thread-Verarbeitung in den Debugger-Meldungen sieht es jetzt logischer aus als vorher.
Bisher ist der Fehler auch nicht mehr aufgetreten. Da die Meldung auch eher sporadisch aufgetreten ist bin ich noch vorsichtig mit Jubelschreien.

Aber erstmal Danke.