Guten Morgen alle...

am Wochenende hab ich mich mal mit Threads intensiv beschäftigt. Zuerst hab ich die OmniThreadLibary ausprobiert. So viele MemoryLeaks (aus der Libary) hab ich in meinem Leben noch nicht gesehen. Danach hab ich TThread versucht.
Nach gefühlten hunderten Forenbeiträgen, Hilfeseiten und ausprobieren dessen habe ich das Gefühl die Katze beißt sich in den Schwanz...
Gegeben:
- Mainunit
- UnitA
- enthällt KlasseA
- UnitB
- enthällt KlasseB(TThread) mit IdHTTP
Funktion:
- Mainunit instanziert Objekt von KlasseA
- KlasseA erzeugt TObjectlist für die Threads
- KlasseA erzeugt Objekte von KlasseB (je nach Anfrage 1-4)
- beim Erzeugen des Threads wird der Thread in die Objectlist gelegt
- im OnTerminate des Threads das Objekt aus der Liste entfernt
- Threads sollen parallel laufen also nicht warten bis einer fertig ist

Solange das Programm beendet wird wenn kein Thread am laufen ist, ist alles in Ordnung. Wird die Anwendung bei laufenden Threads beendet bleiben die Threads stehen Macht man weiter gibt es MemoryLeaks in den Indys weil die Threads einfach abgewürgt werden. Ok, dachte ich, manuell entfernen...

Variante 1:
- FreeOnTerminate:= True // Threads sollen sich selbst freigeben wenn beendet

markieren

Delphi-Quellcode:

destructor KlasseA.Destroy;
begin
  while not (FThreadList.Count = 0) do
    begin
      if Assigned((FThreadList.Items[0] as KlasseB)) then
        (FThreadList.Items[0] as KlasseB).WaitFor;
    end;
end;

* gibt Zugriffsverletungen... Inzwischen weiß ich, daß WaitFor in Verbindung mit FreeOnTerminate nicht zu gebrauchen ist, da das Handle irgendwo weggeworfen wird und dieser "Bug" schon ein paar Jahre existiert.

Variante 2:
- FreeOnTerminate:= False;

zusammenfalten · markieren

Delphi-Quellcode:

destructor KlasseA.Destroy;
begin
  while not (FThreadList.Count = 0) do
  begin
    if Assigned((FThreadList.Items[0] as KlasseB)) then
    begin
     (FThreadList.Items[0] as KlasseB).WaitFor;
     (FThreadList.Items[0] as KlasseB).Free;
    end;
  end;
end;

* soweit so gut. Die aktuellen Threads laufen fertig und sind freigegeben. Nur hab ich dann Im laufenden Betrieb noch haufenweise Objekte im Speicher, welche nicht mehr in der ObjectList stehen, da die Threads sich im OnTerminate austragen.

Wo gebe ich quasi im laufenden Betrieb die Objekte frei ? (nach OnTerminate). Die Beiträge in den Foren laufen alle im Prinzip auf folgendes hinaus:

markieren

Delphi-Quellcode:

Thread.Create;
///
Thread.WaitFor;
ThreadFree;

* das funktioniert auch, nur laufen die Threads nicht parallel sondern nacheinander. (logisch)

Bitte bringt etwas Licht ins Dunkel... Danke

Guten Morgen,

wenn Du die Threads weiter mit freeOnTerminate = true startest
und in der Form im onCloseQuery abfragst ob noch Threads laufen.
ObjectList.count > 0 und die noch laufenden Threads
dann terminierst (oder wartest bis sie abgearbeitet sind)
sollte es doch "eigentlich" zu keinen Problemen kommen.

Grüße
Klaus

Zitat:

Form im onCloseQuery abfragst ob noch Threads laufen.

...das dumme ist nur, daß die Threads stehen bleiben wenn du dich im OnClose OnCloseQuery befindest. (warum auch immer das so ist... wenn das einer logisch erklären kann, bitte) Das war ja mein erster Ansatz... Warten bis die Liste leer ist. Im OnClose / OnCloseQuery kannst du warten bis du schwarz wirst

...aber Danke für deine Hilfe.

Nachtrag: Nur mit WaitFor bringt man den entsprechenden Thread zum weiterlaufen. Funktioniert aber nur bei FreeOnTerminate:= False. Und dann stehen wir wieder am Anfang...wo gebe ich die Threads frei ?

Hallo,

mal ein kleines Konstrukt:

zusammenfalten · markieren

Delphi-Quellcode:

constructor TTestThread.create;
begin
  inherited create(false);
  freeOnTerminate := true;
end;

procedure TTestThread.execute;
begin
  while not terminated do
    begin
      sleep(100);
    end;
end;


procedure TForm1.Button1Click(Sender: TObject);
begin
  ThreadList.Add(TTestThread.Create)
end;

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  showMessage(intToStr(threadList.count));
  threadList.free;
end;

procedure TForm1.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
var
  i : Byte;
begin
  canClose := false;
  while ThreadList.Count > 0 do
    begin
      for i:= ThreadList.count -1 downto 0 do
        begin
          (ThreadList[i] as TTestThread).terminate;
          while not (ThreadList[i] as TTestThread).Terminated do
            begin
              sleep(200);
            end;
           ThreadList.Delete(i);
        end;
    end;
  canClose := true;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  ThreadList := TObjectList.Create(false);
end;

Grüße
Klaus

Danke für deine Mühe...

markieren

Delphi-Quellcode:

for i:= ThreadList.count -1 downto 0 do
  begin
   (ThreadList[i] as TTestThread).terminate;
   while not (ThreadList[i] as TTestThread).Terminated do
   begin
   sleep(200);
   end;
   ThreadList.Delete(i);
 end;

aus dieser Schleife kommst du nicht mehr raus, da die Threads einfach stehen. Da kannst du Terminate setzen wie du willst. Terminated wird nie True, weil die Threads nicht arbeiten. Sprich Threadlist.Count bleibt immer das gleiche. Würden die Threads ganz normal weiterlaufen würde dein Konstrukt funktionieren.

Unter Delphi 2007 funktioniert das Beispiel einwandfrei.

Hallo,

schon merkwürdig.

Wenn ich im execute des Threads ein Sleep von 20 einsetze funktioniert es so
wie Du beschrieben hast.

Wenn ich aber ein Sleep von 100 einsetze terminiert der Thread und ich bekomme am Ende
die Messagebox angezeigt.

Grüße
Klaus