Hi,

im FormCloseQuery frage ich meine Objectlist ab, on moch Thread vorhanden sind und wenn ja sollen diese sofort beendet werden.

markieren

Delphi-Quellcode:

  if FThread_liste.Count <> 0 then Begin
    for i := 0 to FThread_liste.Count -1 do begin
      if Assigned((FThread_liste.Items[i] as TThread)) then
        (FThread_liste.Items[i] as TThread).Terminate;
    end;
  End;

Allerdings alufen die Threads einfach munter weiter.

Fragen die Threads denn regelmäßig ab, ob sie Terminated wurden? (und beenden sich dann auch!)

markieren

Delphi-Quellcode:

while not (FThread_liste.Items[i] as TThread).Terminated do
  Delay(200);

[dcc32 Fehler] Form_Main.pas(1662): E2362 Auf protected-Symbol TThread.Terminated kann nicht zugegriffen werden

Hm

Den Code kann man auch so schreiben

markieren

Delphi-Quellcode:

// OwnsObjects sollte True sein
FThread_liste.Clear;

Zitat von youuu:

markieren

Delphi-Quellcode:

while not (FThread_liste.Items[i] as TThread).Terminated do
  Delay(200);

[dcc32 Fehler] Form_Main.pas(1662): E2362 Auf protected-Symbol TThread.Terminated kann nicht zugegriffen werden

Hm

Die Threads und nicht die Thread-Liste sollen ja auch das Terminated auswerten.
Der Code zeigt allerdings auch, dass du das eben nicht machst, da du augenscheinlich nicht weißt, wo und wozu man das benutzt.

markieren

Delphi-Quellcode:

procedure TMyThread.Execute;
begin
  inherited;
  while not Terminted do
  begin
    // tue was hier immer wieder ohne Unterlass, ok bis eben Terminated
  end;
end;

Sir Rufo, das versteh ich nun nicht so ganz, was hat das damit zu tun das der Thread beendet werden soll?
Oder gibt die Liste dann die Threads automatisch frei?

Edit: hab ich eben ausprobiert, thread abeit dennoch weiter.

Zitat von youuu:

Sir Rufo, das versteh ich nun nicht so ganz, was hat das damit zu tun das der Thread beendet werden soll?
Oder gibt die Liste dann die Threads automatisch frei?

Edit: hab ich eben ausprobiert, thread abeit dennoch weiter.

Na logisch, wenn der Thread auch nicht selber schaut, ob er aufhören soll

Eine TObjectList mit TObjectList.OwnsObjects auf True verwaltet die Instanzen des Inhaltes selber und bei Clear werden alle Instanzen (in der Liste) freigegeben.

Ein Thread wird im destructor beendet (Terminate) und die Instanz verschwindet im Nirwana ...

... wenn der Thread-Code auch wirklich aufhört

Zitat von youuu:

markieren

Delphi-Quellcode:

  if FThread_liste.Count <> 0 then Begin
    for i := 0 to FThread_liste.Count -1 do begin
      if Assigned((FThread_liste.Items[i] as TThread)) then
        (FThread_liste.Items[i] as TThread).Terminate;
    end;
  End;

Da der Code ja im TForm.OnCloseQuery laufen soll, solltest du den wie folgt nehmen:

markieren

Delphi-Quellcode:

for i := 0 to FThread_liste.Count - 1 do
  if Assigned(FThread_list.Items[i]) and (FThread_list.Items[i] is TThread) then
    (FThread_liste.Items[i] as TThread).Terminate;

1. Die Überprüfung if FThread_liste.Count <> 0 then ist überflüssig, denn genau das passiert auch bei for i := 0 to FThread_liste.Count - 1 do
2. Triffst du bei FThread_liste.Items[i] as TThread auf ein Element, das nicht von TThread abgleitet wurde, dann bekommst du eine Exception um die Ohren gehauen EInvalidCast. Das Assigned() drumherum hilft dir da auch nicht mehr.

Hier der Test

zusammenfalten · markieren

Delphi-Quellcode:

program dp_180889;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  {System} SysUtils, Contnrs, Classes;

type
  TTestThread = class( TThread )
  protected
    procedure Execute; override;
  end;

  { TTestThread }

procedure TTestThread.Execute;
begin
  inherited;
  while not Terminated do
    begin
      Sleep( 50 ); // immer nur ein wenig schlafen, bis eben Terminated ...
    end;
end;

{$DEFINE UNSICHER}

procedure Test;
var
  LList : TObjectList;
  LIdx : Integer;
begin
  LList := TObjectList.Create( True );
  try

    LList.Add( TTestThread.Create( False ) );
    LList.Add( nil );
    LList.Add( TObject.Create ); // Eine einfache TObject-Instanz
    LList.Add( TTestThread.Create( False ) );
{$IFDEF UNSICHER}
    write( 'UNSICHER: ' );
{$ELSE}
    write( 'SICHER: ' );
{$ENDIF}
    for LIdx := 0 to LList.Count - 1 do
      begin
        write( LIdx, '...' );
{$IFDEF UNSICHER}
        if Assigned( LList.Items[LIdx] as TThread )
{$ELSE}
        if Assigned( LList.Items[LIdx] ) and ( LList.Items[LIdx] is TThread )
{$ENDIF}
        then
          // Threads mitteilen, dass sie sich beenden sollen
          ( LList.Items[LIdx] as TThread ).Terminate;
      end;

    Writeln( 'Fertig' );

    LList.Clear; // Wenn der Befehl durch ist, dann sind auch alle Threads beendet

  finally
    LList.Free;
  end;
end;

begin
  try
    Test;
  except
    on E : Exception do
      Writeln( E.ClassName, ': ', E.Message );
  end;
  Readln;

end.

und das Resultat

markieren

Code:

UNSICHER: 0...1...2...EInvalidCast: Ungültige Typumwandlung
SICHER: 0...1...2...3...Fertig

Wenn Du auf 'is' abfragst, kannst Du hart casten. Das Pattern

markieren

Delphi-Quellcode:

if (foo is TBar) then
  TBar(foo)....
// Ist genauso sicher wie(aber wesentlich schneller als)
if (foo is TBar) then
  (foo as TBar)....

Zusätzlich sollte man noch darauf hinweisen (auch wenn es eigentlich selbstverständlich ist), das ein Thread in seiner Execute-Methode 'immer mal wieder' auf 'Terminated' prüfen sollte, d.h. auch in inneren Schleifen. Die 'Terminate' Methode beendet den Thread nämlich überhaupt nicht, sondern setzt nur das Flag 'Terminated' auf True.

Die Methode sollte also besser heißen: 'TerminateRequest', oder auf deutsch: 'SachDenFredErSollSichMaBeendenAberErMussDasSchonA uchMerkenNe';

Ah ok, jetzt versteh ich es. Danke