TThread und kein Ende in Sicht...

[Schokohase]

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

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.

[Alter Mann]

@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:

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.

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?

[Schokohase]

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

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?

[Schokohase]

Ich habe deinen Source mal etwas überarbeitet (hier nur die geänderten Teile):

Delphi-Quellcode:

procedure TCustomThread.SetCancel(const Value: Boolean);
begin
  if (FCancel <> Value) then
  begin 
    FCancel := Value;
    if Value then
      Terminate;
  end;
end;

procedure TCustomThread.Execute;
var
  I : Integer;
begin
  Stream := TFileStream.Create(FFileName, fmOpenRead);
  try
    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;
    Extract;
  finally
    Stream.Free;
  end;
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);
    end;
  end;
end;

procedure TCustomThread.TerminatedSet;
begin
end;

[Alter Mann]

Moin,

habe den Denkfehler gefunden:

Zitat:

Delphi-Quellcode:

Delphi-Quellcode:

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

Das CT.Free; ist hier Falsch, da der Thread sich ja schon beenden will. Ein erneuter Aufruf verhindert aber die Beendigung, sodass es zu einer Schleife kommt. Anfängerfehler.
Danke an allen für die Hilfe und Entschuldigung.

[TiGü]

Jup, stand schon in Beitrag #4.

[Alter Mann]

Aber nicht warum= super