Unterschied TTread.Synchronize / TThread.Queue

[jaenicke]

Zitat von Harry Stahl:

Zitat von Uwe Raabe:

Du kannst das in deinem Beispiel sehen, wenn du nach dem TParallel.For einfach noch eine Zeile

  ListBox1.Items.Add('Ende'); einfügst.

Das wird dann als erstes in die Liste eingefügt und erst später die Einträge aus dem Parallel.Loop. Daraus kann ich dann folgern, dass ich die ganze Zeit noch im Mainthread war, oder?

Wenn du Queue benutzt, werden die Threadinhalte tatsächlich erst hinterher ausgeführt. Das liegt aber nicht daran, dass die Schleifeninhalte hinterher ausgeführt werden, sondern an der Auskoppelung durch Queue.

Das kannst du sehr gut an diesem Beispiel sehen:

Delphi-Quellcode:

  MessageBox(0, 'Vorher', 'Test', 0);
  TParallel.For (1,2, procedure (i:Integer)
  begin
    MessageBox(0, PChar(i.ToString), 'Test', 0);
  end);
  MessageBox(0, 'Nachher', 'Test', 0);

Du wirst sehen, dass die Messagebox "Nachher" erst angezeigt wird, wenn die beiden anderen bestätigt sind. Das kannst du aber ja auch einfach mit einem Haltepunkt sehen.

[Sir Rufo]

Da in TParallel.&For eben genau dieses Wait gemacht wird, muss/kann man es damit vergleichen.

[Rollo62]

Aber in TParallel laufen doch im besten Fall mehrere Threads parallel ab (hoffentlich).
Und das TaskWait kommt für alle am Ende, oder nicht ?

Wie sollte man das den jetzt aufbauen damit es threadsafe wird, geht das überhaupt ?

Die Strings z.B. in TDictionary o.ä zwischenspeichern, und dann nach der TParallel Schleife in die
Listbox übertragen ?
Oder die gute alte TStringList ?
Dann würden zwar die Berechnungen parallel laufen, aber die Übertragung in die Listbox wieder im Hauptthread.

Dann wäre doch das TParallel in solchen Fällen nicht besonders sinnvoll, nur da wo es keine
Inputs zu Komponenten im Hauptthread geben muss.

Oder gibt es eine Konstellation wie man das auch mit TListBox parallel hinbekommt ?

Rollo

[jaenicke]

Zitat von Rollo62:

Dann wäre doch das TParallel in solchen Fällen nicht besonders sinnvoll, nur da wo es keine
Inputs zu Komponenten im Hauptthread geben muss.

TParallel ist nur für die Daten- und Logikteile der Anwendung gedacht, nicht für die GUI, ja. Ehrlich gesagt habe ich es da aber auch nie vermisst, da im Hauptthread ohnehin keine längeren Operationen laufen sollten. Und der Teil, der TParallel benutzt, ist ja per Definition eine solche längere Operation, sonst bräuchte man ja keine Threads.

Es sollte also in dem Fall einfach ein Thread für die ursprüngliche Verarbeitung gestartet werden und schon ist das Problem gelöst.

[Rollo62]

Hallo jaenicke,

ja schon klar.

Aber ich denke es geht Harry hier um das schnelle Befüllen einer ListBox / ListView.

Wie wäre es wenn man die maximale Anzahl leerer Zeilen zuvor anlegt, und dann mit Parallel schnell füllt,
so das sich jeder Thread nur um seinen Teil der ListBox Einträge kümmern muss.

Dazu müsste dann gewartet werden, und die ListBox natürlich mit Begin- EndUpdate gekapselt werden,
aber das könnte doch das Befüllen beschleunigen, wenn das ListBox Design so etwas zulässt.

Mir ist auch nicht ganz wohl dabei selbst wenn das gehen würde, weil man ja immer in der nächsten Version eine
interne Änderung in der Listbox haben könnte die dann auf einmal Crasht.

Ich würde wohl versuchen so etwas wie eine virtuelle ListBox (als virtualTree) zu bauen, die nur den sichtbaren Teil jeweils nachlädt,
aber ich würde auch erstmal darüber nachdenken warum die StandardListbox das nicht auch kann.

Vielleicht geht es ja doch irgendwie ?

Rollo

[jaenicke]

Ich selbst habe dafür die nötigen Fenster rein über die API erstellt. Dann sind die nämlich threadsicher und ich kann von mehreren Threads aus problemlos über Events auf die GUI zugreifen ohne diese zu synchronisieren.
Allerdings ist das natürlich nicht gerade der Weg, den man in Delphi gehen möchte...

Wenn es um eine Listenanzeige geht, benutze ich dafür in der Tat die VirtualStringTree. Dann aktualisiere ich gesichert per TMonitor die Daten und löse einfach ein Neuzeichnen aus.

[Uwe Raabe]

Zitat von jaenicke:

Ich selbst habe dafür die nötigen Fenster rein über die API erstellt. Dann sind die nämlich threadsicher und ich kann von mehreren Threads aus problemlos über Events auf die GUI zugreifen ohne diese zu synchronisieren.
Allerdings ist das natürlich nicht gerade der Weg, den man in Delphi gehen möchte...

Insbesondere, wenn man das Ganze unter FMX aufzieht um verschiedene Zielplattformen anzusprechen.

[Harry Stahl]

Zitat von Rollo62:

Hallo jaenicke,

ja schon klar.

Aber ich denke es geht Harry hier um das schnelle Befüllen einer ListBox / ListView.
Rollo

Nö, das war nur ein Beispiel mit dem ich ein wenig "gespielt" hatte, um ein mögliches Update der GUI zu prüfen.

Aber ich habe jetzt verstanden, dass man TParallel-For (und auch TTask) im Prinzip in der Hauptsache verwendet, um Prozesse in der Summe schneller bearbeitet zu bekommen (indem eben mehrere Prozessor-Kerne benutzt werden, wenn sie denn zur Verfügung stehen).

Der bisherige "normale" zusätzliche Thread, der Hintergrundarbeit durchführt und hin und wieder mal die GUI aktualisiert scheint mir daher durchaus weiterhin seine Berechtigung zu haben. Oder?

[jaenicke]

Zitat von Harry Stahl:

Der bisherige "normale" zusätzliche Thread, der Hintergrundarbeit durchführt und hin und wieder mal die GUI aktualisiert scheint mir daher durchaus weiterhin seine Berechtigung zu haben. Oder?

Ja, sicher, TParallel ist nur ein kleines Hilfsmittel für kleine Aufgaben um die leichter in Threads zu packen, aber für umfangreichere Aufgaben lohnt sich eher eine Umsetzung mit eigenen Threads oder Tasks.

[Stevie]

Seit der PPL denken plötzlich alle, Multithreading und parallel programming sei nen Kindergeburtstag

TParallel.For ist blockend, d.h. alles, was zurück in diesen Thread synchronisieren will, sorgt für einen Deadlock.

Wenn du innerhalb der Tasks eines parallel for die GUI updaten willst, dann musst du die parallel for in einem eigenen Thread/Task starten.

Hier mal nen kleines Nonsense Beispiel:

Delphi-Quellcode:

  TTask.Run(
    procedure
    begin
      TParallel.&For(0, 1000,
        procedure (i: Integer)
        begin
          Sleep(50);
          TThread.Queue(nil,
            procedure
            begin
              Caption := IntToStr(i);
            end);
        end);
      TThread.Queue(nil,
        procedure
        begin
          ShowMessage('done');
        end);
    end);
  ShowMessage('started');