Hallo,

mein Thread will nicht so wie ich es gern hätte
TerminatedSet wird aufgerufen, aber irgend etwas läuft im Hintergrund weiter,
sodass procedure TThread.DoTerminate; nicht aufgerufen wird und
ich den Hauptthread nicht beenden kann.

Im Anhang ist eine Demo, läuft ab Delphi 2009.

Kannst du vielleicht (zusätzlich) die entscheidenden Codestellen hier posten?
Ich glaube nur wenige Leute haben Lust sich ein ganzes Projekt runterzuladen nur um zu helfen.

Bei mir bleibt dein Programm sogar komplett stehen, wenn ich auf Start drücke.
Ein Exit; direkt nach Begin von Thread Execute lässt das Programm auch hängen. Der Fehler könnte irgendwo davor oder danach sein aber nicht im Execute.

Wenn ich eine (1) Datei mit deinem Programm öffne kann man auch sehen, dass das Programm bis 50% der Progressbar reagiert und dann nicht mehr.


>
Das Problem hat irgendwas mit der Zeile
CT.OnTerminate := TerminateEvent;
zu tun. Lässt man die weg funktioniert alles.
Genauer gesagt liegt es am CT.Free;.

Ein FreeOnTerminate := True; ins Thread Create hilft und es gibt keine Speicherlecks. Aber ich weiß nicht, ob das die Lösung ist.

Ich glaube dein Ansatz mit dem TerminateSet und all das ist vergleichbar mit einer Person, die sich mit einem Presslufthammer den Fußboden im ersten Stock abbaut und noch drauf steht. Sicher bin ich mir aber nicht.

Oder einfach das CT.Free; im TForm1.TerminateEvent rausnehmen und ins FormDestroy verschieben.
Ggf. btnCancelClick noch ergänzen zu:

markieren

Delphi-Quellcode:

procedure TForm1.btnCancelClick(Sender: TObject);
begin
  if Assigned(CT) and CT.Started then
    CT.Cancel := true;

  CT.Free;
  CT := nil;
end;

Danke für die Tipps und Hinweise.

Bin ein kleines Stück weiter gekommen.

Da ich während des schreibens abgemeldet wurde, dass ganze nocheinmal.

Ich habe den Code ein wenig an die Hinweise angepasst.

Die Thread-Klasse:

zusammenfalten · markieren

Delphi-Quellcode:

  TCustomThread = class(TThread)
  strict private
    Stream : TFileStream;
    StreamSize : Int64;
    ReadSize : Int64;
    iSize : Integer;
  private
    FCancel : Boolean;
    FFileName : string;
    FIsOpen : Boolean;
    FOnLog : TLogEvent;
    FOnProgress : TProgressEvent;
    procedure SetCancel(const Value : Boolean);
    procedure SetFileName(const Value : string);
  protected
    procedure DoLog(Value : string);
    procedure DoProgress;
    procedure Execute; override;
    procedure Extract;
    {$IFDEF VER200}
    procedure Terminate; reintroduce;
    procedure TerminatedSet;
    {$ELSE}
    procedure TerminatedSet; override;
    {$ENDIF}
  public
    constructor Create; reintroduce;
    destructor Destroy; override;

    property Cancel : Boolean read FCancel write SetCancel;
    property FileName : string read FFileName write SetFileName;
    property OnProgress : TProgressEvent read FOnProgress write FOnProgress;
    property OnLog : TLogEvent read FOnLog write FOnLog;
  end;
  
constructor TCustomThread.Create;
begin
  inherited Create(True);
  iSize := 0;
  ReadSize := 0;
  StreamSize := 0;
  FCancel := False;
  FFileName := EmptyStr;
  FIsOpen := False;
end;

destructor TCustomThread.Destroy;
begin
  inherited Destroy;
end;
  
procedure TCustomThread.Execute;
var
  I : Integer;
begin
  if not FIsOpen then
  begin
    Stream := TFileStream.Create(FFileName, fmOpenRead);
    FIsOpen:= Stream.Handle <> INVALID_HANDLE_VALUE;
    if FIsOpen then
    begin
      StreamSize := Stream.Size;
      I := 10;
      while (StreamSize div I) > MaxInteger do
      I := I * 10;
      iSize := StreamSize div I;
    end;
  end;
  Extract;
end;

procedure TCustomThread.Extract;
var
  iRead : Int64;
begin
  if FIsOpen then
  begin
    while (ReadSize <> StreamSize) and (not Terminated) do
    begin
      iRead:= iSize;

      Inc(ReadSize, iRead);

      if (StreamSize - ReadSize) < iSize then
        iSize := StreamSize - ReadSize;

      if Assigned(FOnProgress) then
        Synchronize(DoProgress);

      Sleep(50);

      if (StreamSize = ReadSize) or FCancel then
        Terminate;
    end;
  end;
end;

procedure TCustomThread.TerminatedSet;
begin
  if FIsOpen then
  begin
    Stream.Free;
    FIsOpen := False;
    iSize := 0;
    ReadSize := 0;
    StreamSize := 0;
  end;
end;

Erzeugt, gestartet und gestoppt wird sie so:

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
begin
  LogMemo.Lines.Clear;

  CT := TCustomThread.Create;
  CT.OnProgress := ProgressEvent;
  CT.OnLog := LogEvent;
  CT.OnTerminate:= TerminateEvent;
end;

procedure TForm1.btnStartClick(Sender: TObject);
begin
  if Assigned(CT) then
  begin
    CT.FileName := EditFile.Text;
    {$IFDEF VER200}
    CT.Resume;
    {$ELSE}
    CT.Start;
    {$ENDIF}
  end;
end;

procedure TForm1.btnCancelClick(Sender: TObject);
begin
  if Assigned(CT) and CT.Started then
    CT.Cancel := true;
end;

Interessant wird es hier:

markieren

Delphi-Quellcode:

procedure TForm1.TerminateEvent(Sender : TObject);
begin
  CT.Free;
  Log('TerminateEvent');
end;

Setze ich auf CT.Free einen Breakpoint und steppe rein, geht es zu TCustomThread.Destroy.
Als nächstest wird TCustomThread.TerminatedSet angesprungen und dort ist FIsOpen = False!
Was ja richtig ist, denn laut System.Classes und Log-Ausgabe wird TerminatedSet doch schon vorher
durch Terminate aufgerufen. Warum also der erneute Aufruf von Destroy?

Ich bin mir noch immer sicher CT.Free; kann nicht gut gehen, da es aus dem Kontext des Threads aufgerufen wird.

Du erstellst CT doch im FormCreate. Dann kann Free auch ins FormDestroy.

JaNein.

Die Erstellung im Form.Create ist nur in der Demo so.
Das Problem und das hast du ja schon geschreiben, ist im CT.Free
und den damit verbundenen doppelten Aufruf von TerminatedSet.

Zitat von Alter Mann:

Setze ich auf CT.Free einen Breakpoint und steppe rein, geht es zu TCustomThread.Destroy.
Als nächstest wird TCustomThread.TerminatedSet angesprungen und dort ist FIsOpen = False!
Was ja richtig ist, denn laut System.Classes und Log-Ausgabe wird TerminatedSet doch schon vorher
durch Terminate aufgerufen. Warum also der erneute Aufruf von Destroy?

Eventuell weil das so programmiert wurde? Oh, ja ein Blick in den Source und schon weiß man mehr

zusammenfalten · markieren

Delphi-Quellcode:

destructor TThread.Destroy;
begin
  if (FThreadID <> 0) and not FFinished and not FExternalThread then
  begin
    Terminate;
    if FCreateSuspended or FSuspended then
      Resume;
{$IFDEF MSWINDOWS}
    while not FStarted do
{$ELSE}
    while not ((not FCreateSuspended or FInitialSuspendDone) and FStarted) do
{$ENDIF}
      Yield;
    WaitFor;
  end;
  RemoveQueuedEvents(Self);
{$IF Defined(MSWINDOWS)}
  if (FHandle <> 0) and not FExternalThread then CloseHandle(FHandle);
{$ELSEIF Defined(POSIX)}
  // This final check is to ensure that even if the thread was never waited on
  // its resources will be freed.
  if (FThreadID <> 0) and not FExternalThread then pthread_detach(pthread_t(FThreadID));
  pthread_mutex_destroy(FCreateSuspendedMutex);
{$ENDIF POSIX}
  inherited Destroy;
  FFatalException.Free;
end;

Es stellt sich natürlich die Frage, warum du in TerminatedSet den Stream freigibst.

Das ist ungefähr so, als wenn du bei einem fahrenden Auto einfach mal die Zündkerzen ausbaust, weil du willst das Auto ja eh anhalten.

Lass das Auto (den Thread) doch erst mal zum Stehen kommen.

@Schokohase

Welchen Teil hast du nicht verstanden?

In der Hilfe steht:

Zitat:

Die vorzeitige Beendigung eines Threads kann mit der Methode Terminate ausgelöst werden.

Was hier geschied:

zusammenfalten · markieren

Delphi-Quellcode:

procedure TCustomThread.Extract;
var
  iRead : Int64;
begin
  if FIsOpen then
  begin
    ...

    if (StreamSize = ReadSize) or FCancel then
      Terminate;
  end;
end;

Weiterhin heißt es in der Hilfe:

Zitat:

Anmerkung: Im Gegensatz zur Windows-API-Funktion Terminate, die den Thread sofort abbricht, fordert die Methode Terminate nur an, dass der Thread beendet wird. So kann der Thread vor Beendigung noch sämtliche Bereingungen durchführen.

Und dazu gehört auch, dass der Stream geschlossen und alle anderen Bereiche/Variablen freigegeben werden.
Da man Terminate nicht überschreiben kann, lohnt ein Blick in die System.Classes und sieht das Terminate die virtuelle
Procedure TerminatedSet aufruft, die selbst aber nichts macht.

zusammenfalten · markieren

Delphi-Quellcode:

procedure TThread.Terminate;
begin
  if FExternalThread then
    raise EThread.CreateRes(@SThreadExternalTerminate);
  FTerminated := True;
  TerminatedSet;
end;

procedure TThread.TerminatedSet;
begin
end;

Ist damit deine Frage beantwortet?

Zurück zum Thema bzw. meiner Frage.
Wenn, wie o.a. Terminate zur Beendigung aufgerufen werden kann, warum wird Terminate innerhalb von Destroy nochmals
aufgerufen?

Wenn du den Text der Hilfe auch beherzigst, und zwar ganz exakt und penibel

Zitat:

.. fordert die Methode Terminate nur an, dass der Thread beendet wird. So kann der Thread vor Beendigung noch sämtliche Bereingungen durchführen.

Es soll eben NICHT beim Aufruf der Terminate Methode bereinigt werden (so wie du das aber machst), sondern der Thread soll damit signalisiert werden, sobald es geht sich beenden und die Bereinigung durchführen.

Kleine Gedankenstütze wie das gedacht wäre

zusammenfalten · markieren

Delphi-Quellcode:

procedure TMyThread.Execute;
var
  SomeInstance: TObject;
begin
  SomeInstance := TObject.Create;

  while not Terminated do
  begin
    // der Thread macht hier seine Arbeit
  end;

  // Aufräumen
  SomeInstance.Free;
end;

Nachtrag:

Das Aufrufen von Terminate vom ThreadKontext selber ist auch total überflüssig. Die Terminate-Methode soll eine Möglichkeit geben, dem laufenden ThreadKontext zu signalisieren, dass er sich doch bitte beenden soll (sobald als möglich).

Also das ist wie wenn dich jemand darum bittet, dein aktuelles Telefongespräch zu beenden. Würdest du dich auch selber bitten das Gespräch zu beenden?