Arbeiten mit TThreadList

[Der schöne Günther]

Das ist die TThreadList aus System.Classes oder System.Generics.Collections , oder? Ich kann der nichts abgewinnen: Da fehlen elementarste Dinge wie ein GetEnumerator() und alles. Bist du sicher, dass du die brauchst? Ich hätte gedacht, dass du die RS232-Threads alle im Hauptthread erstellst und an die Liste dranhängst und ebenso dort auch die Liste wieder zumachen willst?

Ich nehme da einfach eine ganz "normale" Objektliste (TObjectList )- Soweit die OwnsObjects = True hat, ist die Freigabe der Liste mitsamt aller enthaltenen Threads so einfach wie ein meineListe.Free(); Bsp:

Delphi-Quellcode:

program Project4;

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

uses
   System.SysUtils,
   System.SyncObjs,
   System.Classes,
   System.Generics.Collections;

const
   numThreads: Integer = 5;

var
   threadList: TObjectList<TThread>;
   threadNum: Integer;
   threadIterator: TThread;
   consoleCs: TSynchroObject;

//{$DEFINE OWNSOBJECTS}

procedure writeConsole(const line: String);
begin
   consoleCs.Acquire();
   try
      WriteLn(line);
   finally
      consoleCs.Release();
   end;
end;

function constructRunningThread(const threadNum: Integer): TThread;
begin
   Result := TThread.CreateAnonymousThread(
      procedure
      begin
         writeConsole('Thread ' + threadNum.ToString() + ' startet...');
         sleep(1000 + Random(4000));
         writeConsole('Thread ' + threadNum.ToString() + ' endet...');
      end
   );
   Result.FreeOnTerminate := {$IFDEF OWNSOBJECTS}False{$ELSE}True{$ENDIF};
   Result.Start();
end;

begin
   try
      consoleCs := TCriticalSection.Create();

      writeConsole('Erstelle und fülle Liste...');
      threadList := TObjectList<TThread>.Create(
         {$IFDEF OWNSOBJECTS}True{$ELSE}False{$ENDIF}
      );
      for threadNum := 0 to Pred(numThreads) do
         threadList.Add(constructRunningThread(threadNum));

      writeConsole('Baue Liste ab...');
      threadList.Destroy();
      writeConsole('Liste abgebaut');
      writeConsole('<Taste drücken>');
   except
      on E: Exception do
         WriteLn(E.ClassName, ': ', E.Message);
   end;

   ReadLn;
end.

// Roter Kasten:
Entweder ein TThread hat FreeOnTerminate = True und du fasst ihn nach dem Starten nicht mehr an(!) oder er hat es auf False und du gibst die TThread-Instanz selbst so frei wie du möchtest. Ich habe das mal versucht in das Beispiel zu packen: Du kannst das {$DEFINE OWNSOBJECTS} einmal auskommentieren und dir den Unterschied anschauen

[pertzschc]

Zitat von Der schöne Günther:

Ich habe das mal versucht in das Beispiel zu packen

Mit welchem Delphi läuft Dein Code? Bei mir im Delphi 2010 geht z.B. das TThread.CreateAnonymousThread nicht.

Danke für einen Hinweis,
Christoph

[Der schöne Günther]

Zitat von pertzschc:

Zitat von Der schöne Günther:

Ich habe das mal versucht in das Beispiel zu packen

Mit welchem Delphi läuft Dein Code? Bei mir im Delphi 2010 geht z.B. das TThread.CreateAnonymousThread nicht.

Das war XE5 oder XE6, weiß ich nicht mehr.
Vielleicht kam das erst mit XE?
Aber ansonsten wäre es kein Unterschied, stattdessen mit (weitaus mehr Tippaufwand) sich auf klassischem Wege wieder eine Klasse TMyThread = class(TThread) zu definieren, Execute() zu implementieren und den letztendlich zurückzugeben.

[Sir Rufo]

Ich verstehe gar nicht, was dieses Gehampel mit den Threads soll.

1. Ein Thread sollte sich bei TThread.Terminate von selber auch sauber beenden (muss nicht schlagartig sein, aber er sollte sich ab jetzt nur noch Augen für das Sandmännchen haben)
2. TThread.FreeOnTerminate - habe ich mal benutzt, ist aber ewig her, weil es mehr Probleme schafft als wirklich hilft

Solche Threads packt man einfach in eine ganz normale TObjectList (ja, OwnsObjects auf True) und wenn diese Threads aus dem Speicher sollen, dann ein ganz lapidares freigeben der Liste.

Ein Thread ruft im Destroy ganz von alleine das TThread.Terminate auf, dann ein TThread.WaitFor .

Fazit: Die Thread-Klasse sauber aufbauen, dann klappt das wie von selber

[Dejan Vu]

Zitat von Sir Rufo:

Ein Thread ruft im Destroy ganz von alleine das TThread.Terminate auf, dann ein TThread.WaitFor .

Fazit: Die Thread-Klasse sauber aufbauen, dann klappt das wie von selber

Na ja. Ich hatte immer Probleme (vielleicht älteres Delphi), einen Thread einfach so freizugeben. Erst seitdem ich Terminate,WaitFor,Free aufrufe, klappt es. Vielleicht ist das ja auch Aberglaube.

[Bjoerk]

Apropos WaitFor. Darf ich mich mal kurz einklinken? Kann man das auch in den destructor schreiben oder ist es da schon zu spät?

Delphi-Quellcode:

constructor TFindSnapPointsThread.Create(List: TGraphicList);
begin
  inherited Create(true);
  FreeOnTerminate := true;
  FFindSnapPoints := TFindSnapPoints.Create;
  FList := List
end;

destructor TFindSnapPointsThread.Destroy;
begin
  WaitFor;
  FFindSnapPoints.Free;
  inherited Destroy;
end;

procedure TFindSnapPointsThread.Terminate;
begin
  FFindSnapPoints.Cancel := true;
  inherited Terminate;
end;

[Sir Rufo]

Es sollte reichen, wenn du die Instanzen nach dem inherited freigibst.

Delphi-Quellcode:

destructor TFindSnapPointsThread.Destroy;
begin

  inherited;
  FFindSnapPoints.Free;
end;

Um hier aber etwas wirklich konkretes zu sagen, musst du dir dringend einmal anschauen, was in TThread.Destroy so passiert.

In den neueren Delphi-Versionen wird dort eben genau das alles gemacht (Terminate ,WaitFor ,...).

Zitat von Dejan Vu:

Zitat von Sir Rufo:

Ein Thread ruft im Destroy ganz von alleine das TThread.Terminate auf, dann ein TThread.WaitFor .

Fazit: Die Thread-Klasse sauber aufbauen, dann klappt das wie von selber

Na ja. Ich hatte immer Probleme (vielleicht älteres Delphi), einen Thread einfach so freizugeben. Erst seitdem ich Terminate,WaitFor,Free aufrufe, klappt es. Vielleicht ist das ja auch Aberglaube.

Das ist bei Delphi 7 wohl noch so, sollte aber auch durch einen Blick in TThread.Destroy zu klären sein, ob das wirklich nötig ist, oder ob es einfach reicht, den echten Destructor abzuwarten und dann erst alles einzureißen (s.o.)