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

achso, wegen der Freigabe in sich selber... Natürlich. Danke.
Nein, eine Exception kommt nicht.
Danke!

Ich habe davon ehrlich gesagt keine Ahnung. Aber ich schätze, dass das Event im selben Kontext steht wie der Thread ansich. Irgendwie so ...
Einfach den Thread ganz abgekoppelt von außerhalb freigeben.

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);