Ein Versuch mit Omnithreadlibrary

[himitsu]

Erstmal arbeitest du mit Threads, wobei du mehrmals "gleichzeitig" auf globale Objekte zugreist.

DU mußt also den Zugriff darauf irgendwie synchronisieren, z.B. mit einer CriticalSection oder passenden threadsicheren Komponenten ala TThreadList.


PS: seit paat Jährchen gibt es auch im Delphi eine immer größerwerdende Thread-Library,
http://docwiki.embarcadero.com/RADSt...amming_Library
wozu es auch einige Tutorials und YT-Videos gibt.


Wenn man keine Kontrolle braucht, wieviele Threads gleichzeitig laufen, oder Dergleichen,
dann reicht auch TThread, welches bereits seit Einführung der Generics nettze Funktionen besitzt.

Delphi-Quellcode:

TThread.CreateAnonymousThread(procedure
  begin
    // im Thread
  end);

TThread.Synchronize(procedure
  begin
    // jetzt im Hauptthread (auf Ende warten, ähnlich SendMessage)
  end);

TThread.Queue(procedure  // hier besser TThread.ForceQueue nutzen
  begin
    // später im Hauptthread (ohne zu warten, ähnlich PostMessage)
  end);

[IMPEGA]

Zitat:

DU mußt also den Zugriff darauf irgendwie synchronisieren, z.B. mit einer CriticalSection oder passenden threadsicheren Komponenten ala TThreadList.

Ja, das stimmt. Den Code habe ich aber aus einem Beispiel von OmniThreadLibrary abgeleitet. Test_46.
Dort ist es auch so deklariert. Ich habe eine interne Schleife zusätzlich eingebaut und paar Sachen die für mich relevant sind dazu geschrieben.
Die Übergabe an den Hauptthread wird dort aber genau so angegeben. Darum frage ich die Profis was Sache ist.
Bin etwas durcheinander. Ich kenne es eigentlich auch so, dass man den Thread synchronisiert und nicht direkt anspricht.
Hier möchte ich noch etwas hinzufügen.
Ich kann mehr oder weniger mit Threads umgehen,bis jetzt habe ich die Class von Delphi-Praxis benutzt. Hat so weit alles gut geklappt.
Mir geht es um das Lernen. OmniThreadLibrary soll wohl sehr gut sein, deshalb versuche ich ein wenig zu testen.
Das ist das Original aus der Hilfe von OmniThreadLibrary

Delphi-Quellcode:

uses
  OtlTaskControl,
  OtlParallel;

{$R *.dfm}

procedure TfrmDemoParallelAsync.btnAsyncClick(Sender: TObject);
begin
  btnAsync.Enabled := false;

  Parallel.Async(
    procedure
    begin
      // executed in background thread
      Sleep(500);
      MessageBeep($FFFFFFFF);
    end,
    Parallel.TaskConfig.OnTerminated(
      procedure (const task: IOmniTaskControl)
      begin
        // executed in main thread
        btnAsync.Enabled := true;
      end
    )
  );
end;

Ok, ich denke hier ist einiges falsch.

Delphi-Quellcode:

                            Status := Liste.Strings[0];
                            Liste.Delete(0);
                            Memo1.Lines.Add(Status);

Meine Frage dazu.
Die ersten zwei Zeilen. Kann ich so auf die Liste zugreifen?
Ich denke, dass die dritte Zeile nun irgendwie synchronisiert werden muss.
Oder sind alle 3 Zeilen in der Form nicht akzeptabel?
Die Threads greifen nämlich auf die globale Liste zu. Darf es so bleiben?

PS: Die Hilfe bei http://docwiki.embarcadero.com ist vorsichtig ausgedrückt sehr mager. Ein Anfänger wird garantiert nie eine Thread basierte Anwendung danach schreiben können.

[himitsu]

Ich nutze die OTL nicht, aber ich bin mir sehr sicher, dass in der Dokumentation oder in Demos niemals derartig auf ungeschützte Objekte zugegriffen wird. (das würde mich jedenfalls sehr wundern, wenn dort derart grob fahrlässige Fehler drin wären)


Klar kann man so darauf zugreifen, aber niemals "ungeschützt" in einem Thread, es sei denn dieser eine Thread ist der Einzige, welcher darauf zugreift.

Der Haupt-/MainThrad ist ja auch ein Thread und so lange etwas ausschließlich darin läuft, kann es z.B. auch problemlos auf die VCL (GUI) zugreifen.

Zitat:

Delphi-Quellcode:

Status := Liste.Strings[0];
Liste.Delete(0);

Wenn ein anderer Thread zwichen diesen Beiden Befehlen die Liste verändert (Add/Append/Delete), dann rate mal was hier wohl schief laufen kann.
Noch schlimmer ist es, dass der andere Thread auch "mitten" in einem der beiden Befehle einschlagen kann ... dann wird nicht nur dieser eine Index betroffen, sondern es kann auch das gesamte Programm zerstören, indem es beim Speichermanagement was schrottet.


* eine CriticalSection um das Auslesen+Delete (alternativ gehen auch andere Synchronisiermethoden, wie z.B. TMonitor.Enter oder siehe SyncObjs)
das Benutzten des "Status" im Anschluss muß nicht da drin sein, da es die "globale" Liste nicht mehr betrifft.

PS: statt Delete kann man auch Remove benuten, dann ist es nur noch ein Befehl.
Aber auch dieser ist nicht "atomar" und muß demach abgesichert werden.

* Rate mal, warum ich die TThreadList erwähnt hab, denn Jene hat bereits eine Sicherung eingebaut, welche Thradübergreifende Konflikte abfängt.


Beispiel für atomare Befehle:
Inc(i); hat Probleme, wenn mehrere Threads gleichzeitig den selben Speicher verändern wollen.
Darum gibt es InterlockedIncrement / InterlockedIncrement, bzw. inzwischen auch AtomicIncrement, als platformübergreifende Variante. (nicht nur Windows, sondern auch Android, iOS usw.)

[IMPEGA]

Danke erstmal.
OK, also nicht so prickelnd.
Gut erklärt, danke, sehe ich ein. Nun schaue ich mir TThreadList an.
Mal schauen was ich da basteln kann.

Falls mir jemand ein einfaches Beispiel in TThreadList zeigen könnte wäre es supi.
Ich fange an zu lesen, es dauert halt immer sehr lange bis ich es verstanden habe. Einfacher Beispiel würde es mir enorm erleichtern.
Wie schon gesagt. Meine Englisch -kenntnisse sind ein Problem.

Im Endeffekt möchte ich eine sehr lange Liste in mehreren Threads abarbeiten.
Daten werden ausgewertet, in eine andere Tabelle eingetragen und die Zeile muss aus der Liste verschwinden.
Vielleicht hat jemand etwas Ähnliches schon parat. Es muss nicht exakt die Lösung für mich sein, es geht um das Verstehen der Verläufe.
Mein Code schreibe ich mir eh selbst.

[IMPEGA]

Neuer Anfang.

Frage an die Profis.
Bin ich damit im Ansatz OK?

Delphi-Quellcode:

    { Private-Deklarationen }
    Fpool : TThreadpool;

...

procedure TForm1.Button5Click(Sender: TObject);
begin
  Memo1.Clear;

  if FPool = nil then
    begin
      Fpool := TThreadPool.Create;
      Fpool.SetMaxWorkerThreads(10);
      Fpool.SetMinWorkerThreads(1);
    end;

  TTask.Run(procedure
    begin
      TParallel.&For(0, 100,  {von 1 to 10}
        procedure(Index : Integer)
          begin
            Sleep(1000);
            Memo1.Lines.Add('TThread.Ergebnis : ' + TTask.CurrentTask.Id.ToString + ' : ' + Index.ToString);

           // KANN ICH HIER AUF EINE GLOBALE STRINGLIST ZUGREIFEN ?????

          end, FPool);
    end);
end;

[supermuckl]

Schon diese Zeile müsste mit dem Hauptthread synchronisiert werden:
Memo1.Lines.Add('TThread.Ergebnis : ' + TTask.CurrentTask.Id.ToString + ' : ' + Index.ToString); Weil die VCL das Memo1 verwaltet und ggf. neu zeichen will, während ein Pool-Thread gerade die Lines verändert.

[TurboMagic]

Wie soll denn auf die Stringliste zugegriffen werden?
Von allen zum Zeitpunkt der Thread Ausführung aktiven Parteien
nur lesend?

Sonst braucht es z. B. eine TCriticalSection mit Aquire und Release
um die Zugriffe herum.