Also per se stimmt mit TSammelListe eigentlich alles. (im Create erstellen und im Destroy freigeben ... beides auf der selben Ebene ist immer gut)

Bist du sicher, dass das Speicherleck "dieses" Objekt ist und nicht irgendwas Anderes?
Was aber niemand verbieter, ins Create und Destroy der TSammelListe einen Haltepunkt oder Logmeldung einzufügen und zu schauen ob und wie oft das erstellt/freigegeben wird.



Was du eventuell noch bedenken mußt, TThread.Create wird immer im erstellenden Thread ausgeührt,
während bei FreeOnTerminate das Thread.Destroy immer im Thread abläuft.
Und bei einem externen .Free das Thread.Destroy ebenfalls in einem anderen Thread.

Aber manche Dinge müssen/dürfen (nur) im selben Thread genutzt werden, wo sie erstellt wurden.
-> Hier geht also nur TComponent.Create und Component.Free mit einem Try-Finally im Execute.



Und was ist TSammelListe?
"Normalerweise" machen Listen im Free automatisch ein Clear, somit würde ein Free ausreichen.

markieren

Delphi-Quellcode:

destructor TAnalyseThread.Destroy;
begin
  FList.Free; // oder FreeAndNil(FList);
  inherited;
end;

[EDIT] Jupp, die Liste gibt "ihre" Items frei, aber nicht die darin gespeicherten Objektreferenzen ... siehe Der schöne Günther

Dein Thread ist in Ordnung, das Problem ist dein TList<TGraphicControl> . Die Liste kannst du so oft clearen und freigeben wie du willst, die gibt ihre enthaltenen Elemente nicht selbst frei.

Was du stattdessen willst ist eine TObjectList<TGraphicControl> .

Zitat von Der schöne Günther:

Dein Thread ist in Ordnung, das Problem ist dein TList<TGraphicControl> . Die Liste kannst du so oft clearen und freigeben wie du willst, die gibt ihre enthaltenen Elemente nicht selbst frei.

Was du stattdessen willst ist eine TObjectList<TGraphicControl> .

Nein, siehe mein Beitrag gerade eben. Die Liste kann man ausklammern, selber Fehler

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;

type
  TAnalyseThread = class(TThread)
  private
  protected
    procedure Execute; override;
  public
    Status : AnsiString;
    OnReady : TNotifyEvent;

    constructor Create(CreateSuspended : Boolean);
    destructor Destroy; override;
  end;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Private-Deklarationen }
    AnalyseThread : TAnalyseThread;

    procedure OnAnalyseReady(Sender: TObject);
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  if Assigned(AnalyseThread) then
  begin
    AnalyseThread.Terminate;
    FreeAndNil(AnalyseThread);
  end;

  AnalyseThread := TAnalyseThread.Create(True);

  if Assigned(AnalyseThread) then
  begin
    AnalyseThread.OnReady := OnAnalyseReady;

    AnalyseThread.Start;
  end;
end;

procedure TForm1.OnAnalyseReady(Sender: TObject);
begin
  //Auswertung des Daten...

  if Assigned(AnalyseThread) then
  begin
    AnalyseThread.Terminate;
    FreeAndNil(AnalyseThread);
  end;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  if Assigned(AnalyseThread) then
  begin
    AnalyseThread.Terminate;
    FreeAndNil(AnalyseThread);
  end;
end;

{ TAnalyseThread }

constructor TAnalyseThread.Create(CreateSuspended: Boolean);
begin
  inherited Create(CreateSuspended);

  FreeOnTerminate := False;
end;

destructor TAnalyseThread.Destroy;
begin
  inherited Destroy;
end;

procedure TAnalyseThread.Execute;
begin
  inherited;

  //Tue irgendwas bis fertig...

  if Assigned(OnReady) then
    OnReady(Self);
end;

end.

Da steht doch in dem Dialog aus #4, dass der Thread selbst nicht freigegeben wurde. (was in dem Thread ist, ist demnach eh egal)

PS: Strg+C im Dialog und dann Strg+V hier in ein [QUOTE] ... das wird als "Text" kopiert.

Woran erkennst du das? Bei mir steht, ein unerwarteter Speicherverlust ist aufgetreten.
Ist doch ein Speicherleck oder nicht?

---------------------------
Unexpected Memory Leak
---------------------------
An unexpected memory leak has occurred. The unexpected small block leaks are:
53 - 60 bytes: TAnalyseThread x 1

markieren

Delphi-Quellcode:

procedure TForm1.OnAnalyseReady(Sender: TObject);
begin
 // Auswertung des Daten...

// if Assigned(AnalyseThread) then
// begin
// AnalyseThread.Terminate;
// FreeAndNil(AnalyseThread);
// end;
end;

Ändere OnAnalyseReady so ab und dein Problem ist erledigt. Jedenfalls auf Basis des Codes aus dem Beitrag hier drüber.

Hier draus muss man jetzt nicht wieder 5 bis 10 Seiten machen. Einfach in den Editor kopieren, selber testen, Problem gefunden und erledigt.

Zitat:

---------------------------
Unexpected Memory Leak
---------------------------
An unexpected memory leak has occurred. The unexpected small block leaks are:
53 - 60 bytes: TAnalyseThread x 1

wie groß: was vermutet (wenn erkannt) x wie oft

Zitat:

Ändere OnAnalyseReady so ab und

Ohhh.

OK, sich selbst kann man nicht in sich freigeben.
Ja, hier knallt es dann, aber "leider" werden Exceptions innerhalb von Threads nicht angezeigt.
Delphi fängt solche Exceptions aber ab, genauso wie in FVL/FMX ist überall ein Try-Except drumrum (nur in VCL/FMX dann noch mit einem ShowException).

Aber im Debugger müsstest du diese Exception sehen können

Ok, könnt ihr mir noch kurz erklären, warum der Thread im OnAnalyseReady nicht freigegeben werden darf, wenn das doch das Event für mich ist, wo er fertig ist

Thread-Exceptions ausgeben

zusammenfalten · markieren

Delphi-Quellcode:

type
  TAnalyseThread = class(TThread)
  protected
    procedure DoTerminate; override; // oder z.B. als MyOnTerminate über OnTerminate
  end;

procedure TAnalyseThread.DoTerminate;
begin
  if Assigned(FatalException) then begin // FatalException ist ausschließlich im OnTerminate/DoTerminate verfügbar
    var S := Exception(FatalException).Message; // Exception oder Message kopieren/klonen, denn später im Queue ist sie schon weg.
    TThread.Queue(nil, procedure
      begin
        MessageBox(Application.MainFormHandle, PChar(S), 'Thread-Error', MB_OK or MB_ICONERROR);
      end);
  end;
  inherited;
end;

oder über das Event

markieren

Delphi-Quellcode:

constructor TAnalyseThread.Create(CreateSuspended: Boolean);
begin
  OnTerminate := MyOnTerminate;
  inherited;
end;

oder

zusammenfalten · markieren

Delphi-Quellcode:

procedure TAnalyseThread.Execute;
begin
  try

    ... // hier dazwischen alles erstellen/freigeben ... nichts im Create/Destroy

  except
    on E: Exception do begin
      var S := E.Message; // Exception oder Message kopieren/klonen, denn später im Queue ist sie schon weg.
      Queue(procedure
        begin
          MessageBox(Application.MainFormHandle, PChar(S), 'Thread-Error', MB_OK or MB_ICONERROR);
        end);
    end;
  end;
end;

Und es ist absichtlich Queue anstatt Synchronize, damit ein Deadlock beim Freigeben verhindert wird.
z.B. Thread wartet auf MainThread, aber MainThread wartet im Thread.Free auf das Thread-Ende.


PS:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TAnalyseThread = class(TThread)
  public
    OnReady: TNotifyEvent;
    constructor Create(OnReady: TNotifyEvent=nil);
  end;

constructor TAnalyseThread.Create(OnReady: TNotifyEvent);
begin
  inherited Create(not Assigned(OnReady));
  Self.OnReady := OnReady;
  FreeOnTerminate := False;
end;

und dann anstatt

Zitat:

zusammenfalten · markieren

Delphi-Quellcode:

  if Assigned(AnalyseThread) then
  begin
    AnalyseThread.Terminate;
    FreeAndNil(AnalyseThread);
  end;

  AnalyseThread := TAnalyseThread.Create(True);

  if Assigned(AnalyseThread) then
  begin
    AnalyseThread.OnReady := OnAnalyseReady;

    AnalyseThread.Start;
  end;

nur noch ein

markieren

Delphi-Quellcode:

  FreeAndNil(AnalyseThread);
  AnalyseThread := TAnalyseThread.Create(OnAnalyseReady);

So eher nicht:

markieren

Code:

Unit1.TAnalyseThread.Destroy
System.TObject.Free
Unit1.TForm1.OnAnalyseReady($2E7DDC0)
Unit1.TAnalyseThread.Execute
System.Classes.ThreadProc($2E7DDC0)
System.ThreadWrapper($2E4A4A0)
:7749fa29 KERNEL32.BaseThreadInitThunk + 0x19
:775e76b4 ntdll.RtlGetAppContainerNamedObjectPath + 0xe4
:775e7684 ntdll.RtlGetAppContainerNamedObjectPath + 0xb4

Erzeugen im Mainthread und im TAnalyseThread-Kontext freigeben ist halt eher ungünstig!

Biete folgende Lösung an:

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;

type
  TAnalyseThread = class(TThread)
  private
  protected
    procedure Execute; override;
  public
    constructor Create(CreateSuspended: Boolean);
    destructor Destroy; override;
  end;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    AnalyseThread: TAnalyseThread;

    procedure OnAnalyseReady(Sender: TObject);
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}


procedure TForm1.Button1Click(Sender: TObject);
begin
  if Assigned(AnalyseThread) then
  begin
    FreeAndNil(AnalyseThread);
  end;

  AnalyseThread := TAnalyseThread.Create(True);

  if Assigned(AnalyseThread) then
  begin
    // neu, jetzt noch besser!
    AnalyseThread.OnTerminate := OnAnalyseReady;

    AnalyseThread.Start;
  end;
end;

procedure TForm1.OnAnalyseReady(Sender: TObject);
begin
  // Auswertung des Daten...

  if Assigned(AnalyseThread) then
  begin
    // Wir sind mit allen durch, aber können hier noch nicht freigeben, weil wir noch zu sehr im Sumpf
    // des Synchronize drin sind (siehe procedure TThread.DoTerminate;). Darum noch ne Extra-Runde durch
    // die Windows-Botschaftsbehandlung durch TThread.ForceQueue
    TThread.ForceQueue(nil,
      procedure
      begin
        FreeAndNil(AnalyseThread);
      end);
  end;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  if Assigned(AnalyseThread) then
  begin
    FreeAndNil(AnalyseThread);
  end;
end;

{ TAnalyseThread }

constructor TAnalyseThread.Create(CreateSuspended: Boolean);
begin
  FreeOnTerminate := False;
  inherited Create(CreateSuspended);
  TThread.NameThreadForDebugging('TAnalyseThread', Self.ThreadID);
end;

destructor TAnalyseThread.Destroy;
begin
  inherited Destroy;
end;

procedure TAnalyseThread.Execute;
begin
  // Tue irgendwas bis fertig...
end;

end.