Speicherleck bei der Verwendung von anonymen Methoden

[carlo93]

Hallo!

Folgendes Problem:

Bei der Verwendung dieses Quelltextes entsteht ein Speicherleck:

Delphi-Quellcode:

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    Panel1: TPanel;
    Button1: TButton;
    Edit1: TEdit;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    FProc: TProc;
  public
    { Public-Deklarationen }
  end;

procedure TForm1.FormCreate(Sender: TObject);
var
  Func: TFunc<String>;
begin
  ReportMemoryLeaksOnShutdown:=true;
  Func:=
    function: String
    begin
      Result:=Edit1.Text;
    end;
  Memo1.Lines.Add(Func);
  FProc:=
    procedure
    begin
      Memo1.Lines.Add(Func);
    end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  FProc;
end;

Screenshot.jpg

Momentan kann ich leider nicht überprüfen, ob das auch bei XE2 auftritt (meine Testversion ist gerade abgelaufen).
Gibt es eine Möglichkeit, dieses Speicherleck zu verhindern?

[jaenicke]

Umgehen lässt sich das Problem leicht:
Mach aus Func auch ein privates Feld statt einer lokalen Variable.

Schöner ist aber wohl diese Lösung:

Delphi-Quellcode:

procedure TForm142.FormCreate(Sender: TObject);

  procedure DoInit(Func: TFunc<String>);
  begin
    Memo1.Lines.Add(Func);
    FProc :=
      procedure
      begin
        Memo1.Lines.Add(Func);
      end;
  end;

begin
  ReportMemoryLeaksOnShutdown := true;
  DoInit(function: String
    begin
      Result := Edit1.Text;
    end);
end;

[himitsu]

Da wird wohl die eingebetette Reference nicht mehr freigegeben.

Am Generic liegt es nicht, dann wenn man TFunc<String> durch einen richtigen Typen ersetzt, ändert sich nichts.


Lösungen:
- im QC melden und hoffen es wird eventuell irgendwann in den nächsten Jahrzehnten behoben
- auf verschachtelte Referencen verzichten
- oder Func ebenfalls als privates FFunc in der Form speichern [add] wie schonmal genannt
- diesen Fehler einfach ignorieren (wird ja eh nie behoben)
- schmutzige Tricks, um diesen Fehler provisiorisch zu umgehn *1




1) IInterface(PPointer(@Func)^)._Release; als letzen Befehl in FormCreate,
aber sollte dieser Fehler wirklich mal irgendwann behoben werden, dann raucht dir die Anwendung ab.

[jaenicke]

Gerade getestet: Das Problem tritt auch bei XE2 noch auf.

[Bernhard Geyer]

Tritt das Speicherleck bei jeder verwendung auf oder einmalig beim ersten Aufruf?

[jaenicke]

Einmal, es wird ja schließlich die Funktion nicht freigegeben und die existiert nun einmal nur einmal...

// EDIT:
Bzw. wenn man den Code aus FormCreate mehrfach ausführt, wird natürlich bei jeder Ausführung ein Speicherleck produziert.

[Stevie]

Ist schon lange bekannt: QC #83259 und QC #78066.

Tip: Wenn ihr beschleunigen wollt, dass bestimmte Einträge gefixt werden, dann nutzt die Vote Funktion (man kann entgegen dem Irrglauben einiger pro Eintrag 10 Punkte vergeben).

[WladiD]

Zurück zum Thema. Soweit ich mich entsinnen kann, reicht es aus, wenn die Referenz der anonymen Methode explizit auf nil gesetzt wird.

Also in deinem Fall irgendwo im Destruktor:

FProc := nil;

Und der Leak dürfte verschwinden.

[Stevie]

Zitat von WladiD:

Zurück zum Thema. Soweit ich mich entsinnen kann, reicht es aus, wenn die Referenz der anonymen Methode explizit auf nil gesetzt wird.

Also in deinem Fall irgendwo im Destruktor:

FProc := nil;

Und der Leak dürfte verschwinden.

Leider nicht, wie Thom oben schon richtig anmerkte, läuft da irgendwas bei der Code Generierung schief, was dazu führt, dass der RefCount des hinter der anonymen Methode liegenden Objects falsch gezählt wird. Das auf nil setzen geschieht auf jeden Fall implizit. Das ganze (einmal zu oft _AddRef oder einmal zu wenig _Release, wie man will) passiert beim Zusammenspiel von lokaler Variable und verschachtelter anonymer Methode (da wird zu Beginn ein _IntfCopy gemacht, was zu dem erhöhten RefCount führt)

Zusätzlich zu den in den QC Einträgen wäre der simpelste Testcase, der mir gerade einfällt, folgender:

Delphi-Quellcode:

program Test;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type
  TTest = class
  private
    FProc: TProc;
  public
    constructor Create;
  end;

constructor TTest.Create;
var
  Proc: TProc;
begin
  Proc := procedure begin end;
  FProc := procedure begin end;
end;

begin
  ReportMemoryLeaksOnShutdown := True;
  TTest.Create.Free;
end.

[Thom]

Noch eine Merkwürdigkeit im Zusammenhang mit anonymen Methoden:

Eine anonyme Methode ist nach außen hin nur ein einfacher Pointer. Ein SizeOf(TProc) liefert also unter 32 Bit erwartungsgemäß 4 Byte. Im Gegensatz dazu bestehen Objekt-Methoden aus einem Daten- und einem Code-Pointer. Deshalb liefert SizeOf(TMethod)=8 (unter 32 Bit).

Jetzt sollte man natürlich annehmen, daß der doppelt so große Wert von TMethod nicht zuweisungskompatibel zum "kleineren" TProc ist.
Entgegen jeder Logik funktioniert das aber doch: Der Compiler generiert bei einer derartigen Zuweisung einfach eine anonyme Methode und bindet die Variable Self, die zu der Objekt-Methode gehört.
Ich finde dieses Verhalten genial, da damit Ereignishandler wahlweise Objekt- oder anonyme Methoden sein können.

Ein kleines Beispiel:

Delphi-Quellcode:

type
  TNotifyProc = TProc<TObject>; //anstelle von TNotifyEvent

  TMyObject = class
  private
    FValue: Integer;
    FOnChange: TNotifyProc;
    procedure SetValue(Value: Integer);
  public
    property Value: Integer read FValue write SetValue;
    property OnChange: TNotifyProc read FOnChange write FOnChange;
  end;

  TForm1 = class(TForm)
  [...]
  private
    procedure MyObjectChange(Sender: TObject);
  end;

procedure TMyObject.SetValue(Value: Integer);
begin
  if FValue<>Value then
  begin
    FValue:=Value;
    if assigned(FOnChange)
      then FOnChange(Self);
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  MyObject: TMyObject;
begin
  MyObject:=TMyObject.Create;
  try
    MyObject.OnChange:=MyObjectChange;
    MyObject.Value:=1;
    MyObject.OnChange:=procedure(Sender: TObject)
                       begin
                         ShowMessage(IntToStr(TMyObject(Sender).Value));
                       end;
    MyObject.Value:=2;
  finally
    MyObject.Free;
  end;
end;

procedure TForm1.MyObjectChange(Sender: TObject);
begin
  ShowMessage(IntToStr(TMyObject(Sender).Value));
end;