Ist die Verwendung von TTask so korrekt?

[a.def]

Wie der Titel schon erahnen lässt bezweifle ich die Richtigkeit meines Code-Stücks hier.
Ich möchte eine Arbeit starten und dabei den Hauptthread nicht einfrieren lassen.

Delphi-Quellcode:

        TTask.Run(
          procedure
         var
          i: Integer;
         begin
          i := 0;

          while i < 500 do
           begin
            inc(i);
            Sleep(10);
            Caption := IntToStr(i);
           end;
         end);

Das funktioniert einwandfrei. Aber sollte man das nicht eigentlich mit einem

Delphi-Quellcode:

          TThread.Synchronize(nil,
            procedure
           begin
           end);

Ummanteln? Wenn ich das mache, bleibt mein Hauptthread leider stehen bis die 5 Sekunden abgelaufen sind.

[DeddyH]

Sollte das Synchronize nicht einfach nur die Caption-Zuweisung umschließen?

[a.def]

Selbst das hängt die GUI auf. Ich sehe zwar wie sich die Caption ändert aber ich kann sonst nichts mehr machen.
Wenn ich Synchronize einfach weg lasse funktioniert alles. Aber darf man das?

[Luckie]

Ist ja irgendwie logisch. Die Schleife macht ja nichts anders als ein Steuerelement im Formular hochzuzählen. Wenn du das jetzt synchronisierst läuft das ganze quasi im Thread des Formulares.

[a.def]

Aber es heißt doch immer, dass man Zugriffe auf die VCL synchronisieren muss oder ist das hier nicht nötig?

[t.roller]

Verwenden von TTask aus der Parallel Programming Library

[stahli]

Mit Tasks habe ich keine Erfahrungen aber mit Threads schon.

Synchronisieren musst Du Zugriffe auf das Formular, um Zugriffsprobleme zu vermeiden.
Ohne Synchronisation kann es zwar klappen, aber Du kannst auch unvorhersehbare Probleme bekommen (von unauffälligen Datenfehlern bis Abstürzen).

Delphi-Quellcode:

  TThread.Synchronize(nil,
    procedure
      begin
        MyForm.Caption := IntToStr(i);
      end); 
  Sleep(1000);

Wenn Du Dein Sleep auf 1000 einstellst, solltest Du auch den gewünschten Effekt sehen.
Sonst ist die Pause m.E. zu kurz, um etwas zu bemerken und der Mainthread ist voll belastet.

[a.def]

Zitat:

Zitat von t.roller (Beitrag 1357699)

Verwenden von TTask aus der Parallel Programming Library

Abschnitt Eine weitere Funktionalität von TTask ist das Verhindern der Sperrung der Benutzeroberfläche, wenn Sie im Hintergrund etwas starten möchten. Im folgenden Beispiel wird gezeigt, wie Sie eine einzelne Aufgabe ausführen und starten
Danke! TTask benötigt also kein Synchronize.

P.S.:
ich glaube da ist ein Tippfehler in

Zitat:

WaitForAll informiert Sie über den Abschluss aller Aufgaben und WaitForAny über die erste Aufgabe, die abgeschossen wurde.

Ich glaube es sollte abge(l)schossen heißen.

[Uwe Raabe]

Zitat:

Zitat von a.def (Beitrag 1357701)

Danke! TTask benötigt also kein Synchronize.

Wo steht das?

TTask macht einen separaten Thread auf. Der Code, der an TTask übergeben wurde, läuft dann in diesem Thread. Das heißt aber nicht, daß Zugriffe auf die VCL nicht doch synchronisiert werden müssen - so wie in jedem anderen Thread auch.

Dein Beispiel ist irgendwie Nonsens und deswegen liefert es auch keine vernünftigen Ergebnisse. Wenn du alle 10 ms einen Zähler hochzählst und den dann in der Caption darstellst, dann musst(!) du dafür Synchronize oder Queue verwenden. Damit zwingst du den Hauptthread aber alle 10 ms diese Caption zu aktualisieren und das bremst natürlich. Solange also die Aufgabenstellung besagt, daß alle 10 ms die Caption aktualisiert werden muss, kann auch die Verwendung eines Threads den Hauptthread nicht wirklich entlasten.

Threads sind nicht dazu da, viele Zugriffe auf die VCL auszuführen, sondern längere Sequenzen, die nicht mit der VCL rumhantieren, aus dem Hauptthread zu extrahieren, damit die Anwendung weiter auf Benutzereingaben reagieren kann. Das Extrahieren erfordert manchmal schon etwas mehr Überlegung, damit das Ganze auch threadsicher wird.

Stell dir einfach vor, du müsstest eine solche Code-Sequenz als separate Kommandozeilenanwendung schreiben, bei der du Readln und Writeln nur bei Programmanfang und -ende verwenden darfst. Alles dazwischen muss ohne Bildschirmausgaben und Tastatureingaben auskommen. Dieses dazwischen könnte man dann wohl in einen Thread oder auch eine TTask verlagern, um das in einer responsiven UI-Anwendung auszuführen. Daraus folgt dann implizit, daß man in Threads nur sehr sparsam mit Statusmeldungen arbeiten sollte, da diese zwangsweise irgendwie an die UI und somit an den Hauptthread übergeben (synchronisiert) werden müssen.

[t.roller]

Zitat:

Zitat von a.def (Beitrag 1357701)

Zitat:

Zitat von t.roller (Beitrag 1357699)

Verwenden von TTask aus der Parallel Programming Library

Abschnitt Eine weitere Funktionalität von TTask ist das Verhindern der Sperrung der Benutzeroberfläche, wenn Sie im Hintergrund etwas starten möchten. Im folgenden Beispiel wird gezeigt, wie Sie eine einzelne Aufgabe ausführen und starten

Beispiel:

Delphi-Quellcode:

// uses System.Threading,...
procedure TForm1.ButtonClick(Sender: TObject);
var
  lValue: Integer;
begin
    Label1.Caption := '--';
    CheckBox1.Checked:= TRUE;
    TTask.Run(procedure
      begin
          {Some calculation that takes time}
          Sleep(3000);
          lValue := Random(100);
          TThread.Synchronize(nil,
            procedure
            begin
                  CheckBox1.Checked:= FALSE;
                  Label1.Caption := lValue.ToString;
            end);
      end);
//-------------------------------------------------------------------
    Label2.Caption := '--';
    CheckBox2.Checked:= TRUE;
    TTask.Run(procedure
      begin
          {Some calculation that takes time}
          Sleep(6000);
          lValue := Random(100);
          TThread.Synchronize(nil,
            procedure
            begin
                  CheckBox2.Checked:= FALSE;
                  Label2.Caption := lValue.ToString;
            end);
      end);
//-------------------------------------------------------------------
    Label3.Caption := '--';
    CheckBox3.Checked:= TRUE;
    TTask.Run(procedure
      begin
          {Some calculation that takes time}
          Sleep(9000);
          lValue := Random(100);
          TThread.Synchronize(nil,
            procedure
            begin
                  CheckBox3.Checked:= FALSE;
                  Label3.Caption := lValue.ToString;
            end);
      end);
//-------------------------------------------------------------------
end;