Kann ich meine ListView beschleunigen (Icon laden dauert ewig)

[Uwe Raabe]

Zitat von EWeiss:

Jo nichts anderes als PostMessage im weitläufigen sinne.

Nur das Queue eben nicht mit PostMessage arbeitet (muss ja auch für die anderen Plattformen gehen). Wenn man das Szenario mal theoretisch mit der Windows Message Queue umsetzen wollte, dann würde der Thread beim Beenden noch schnell alle PostMessage Calls, die er gemacht hat und die noch in der Message Queue drin stecken einfach da rauslöschen.

@Alle: Es würde mich prinzipiell mal interessieren, ob mein Beispiel auch auf anderen Systemen das Problem verlässlich nachbildet.

[KodeZwerg]

So macht es mehr oder weniger was ich wollte, nun werden nach und nach die icons geladen und dargestellt unabhängig vom mainthread.

Delphi-Quellcode:

procedure TfrmMain.StartIcons3();
begin
  TThread.CreateAnonymousThread(procedure ()
    var
      LIcon: TIcon;
      dummy: Word;
      I: Integer;
    begin
      FileIcons.BeginUpdate;
      LIcon := TIcon.Create;
      LIcon.Transparent := True;
      lvFiles.Column[0].MinWidth := 37;
      lvFiles.Column[0].MaxWidth := 37;
      lvFiles.Column[0].Width := 37;
      lvFiles.SmallImages := FileIcons;
      try
        for i := 0 to lvFiles.Items.Count -1 do
          begin
            dummy := 0;
            TThread.Synchronize (TThread.CurrentThread,
              procedure ()
                begin
                  LIcon.Handle := ExtractAssociatedIcon( hInstance, PWideChar( lvFiles.Items.Item[ i ].Caption ), dummy );
                end);
            LIcon.Transparent := True;
            dummy := FileIcons.AddIcon( LIcon );
            DestroyIcon( LIcon.Handle );
            TThread.Synchronize (TThread.CurrentThread,
              procedure ()
                begin
                  lvFiles.Items.Item[ i ].ImageIndex := dummy;
                end);
          end;
      finally
        TThread.Synchronize (TThread.CurrentThread,
          procedure ()
            begin
              FileIcons.EndUpdate;
            end);
        LIcon.Free;
      end;
    end).Start;
end;

[CCRDude]

Ich finde es gerade nirgendwo dokumentiert, aber so wie die VCL nicht thread-safe ist, würde ich nie Windows-Handles zwischen Threads austauschen. Das knallt im Zweifel irgendwann irgendwo ohne dass man den Kontext erkennt.
Den Icon-Stream zwischen den Threads auszutauschen hat zudem den Vorteil, dass Duplikate einfach vermieden werden können. Und ein Icon-Cache macht gerade bei Netzwerklaufwerken enorm sein.
Spätestens dann machen anonyme Methoden/Threads immer weniger Sinn und schaden massiv der Übersichtlichkeit.

Ich würde das so umsetzen (da fehlt noch ein wenig Fehlerbehandlung, und verbessern kann man natürlich immer):
https://github.com/CCRDude/tlistview-icon-cache-demo
Ist LCL, aber VCL dürfte identisch sein, lediglich die Generics müssten angepasst werden, da nutze ich FreePascal sonst immer im objpas-Modus und bin mir nicht sicher, wie die entsprechenden Delphi-Klassen heißen.

[TiGü]

Zitat von Uwe Raabe:

@Alle: Es würde mich prinzipiell mal interessieren, ob mein Beispiel auch auf anderen Systemen das Problem verlässlich nachbildet.

Ja, es zeigt es ganz gut (Win 10, 10.2.3).
Mit der Verwendung von procedure TThread.Queue(AThreadProc: TThreadProcedure); wird beim Zerstören des Threads alle Warteschlangen-Ereignisse entfernt - da dann hier Self verwendet wird - und man kommt nie bis zur Zahl 100 im Memo.
Oft kommt auch gar nichts an (das hat mich dann doch überrascht).

Wenn man es umschreibt und class procedure TThread.Queue(const AThread: TThread; AMethod: TThreadMethod); mit nil als ersten Parameter verwendet, dann arbeitet der Hauptthread noch alles ab.
Hier geht das natürlich und ist unkritisch, aber wehe, man hat richtigen Code und greift auf Ressourcen des Threads zu.
Vielen Dank, wieder was gelernt.