Dinge in meinen Thread queuen

[Der schöne Günther]

Ich habe bislang oft Sachen in den Hauptthread geschoben. Entweder mittels

Delphi-Quellcode:

TThread.Synchronize(nil, meineProzedur);

oder

Delphi-Quellcode:

TThread.Queue(nil, meineProzedur);

. So schön einfach.

Jetzt habe ich aber die Situation, dass ich etwas in einen anderen TThread queuen möchte. Was muss der Thread dafür tun? Er soll, wenn er die Zeit hat, die Sachen in seiner "To Do"-Liste abarbeiten.

Ich hätte jetzt etwas wie

Delphi-Quellcode:

ExecuteQueuedMethods

() erwartet dass ich in meiner Execute-Prozedur ausführen kann, aber das einzige was ich finden konnte war das genannte

Delphi-Quellcode:

RemoveQueuedEvents

. Das scheint die Queue aber nur zu leeren, nichts darin auszuführen. Die Doku gibt keine weiteren Ideen und aus dem undokumentierten Quelltext werde ich auch nicht schlau.

[Uwe Raabe]

Der Thread führt einfach nur das Execute aus und beendet sich. Was auch immer darin gemacht wird, ist vollkommen deine Sache. Solch eine ToDo-Liste mit einem abarbeitenden WorkerThread musst du halt selbst programmieren - es gibt aber schon was fertiges: z.B: OmniThreadLibrary

[himitsu]

Das "ExecuteQueuedMethods" nennt sich Classes.CheckSynchronize und das wird von der Messagebehandlung in Application aufgerufen.
Es lässt sich auch nir vom MainThread aus aufrufen und wirft ansonsten eine Exception.

RemoveQueuedEvents entfernt eine bestimmte, über TThread.Synchronize oder TThread.Queue hinzugefügte, Methode aus der Warteliste, bzw. alle von einem bestimmten Thread aus hinzugefügten Methoden, oder eine Kombination aus Beidem (Methode von bestimmten Thread).
(natürlich nur solange sie noch nicht ausgeführt wurden :stupid:)

Das was du willst, gibt es im Delphi noch nicht. (abgesehn von einigen Fremdkomponenten, die sich auf die Threadbehandlung spezialisiert haben)


Du kannst eine TThreadList oder TQueue<T> (mit zusätzliches CriticalSection) verwenden, um deine Aufgaben zu sammeln und rufst sie dann selber im Thread auf.

[Der schöne Günther]

Zitat:

Zitat von Uwe Raabe (Beitrag 1267167)

musst du halt selbst programmieren

Zitat:

Zitat von himitsu (Beitrag 1267169)

Das was du willst, gibt es im Delphi noch nicht.

Schade.

Überrascht mich, aber bei der geballten Kompetenz glaube ich das :wink:

[DSP]

Gibts da nicht den http://www.delphipraxis.net/93835-wo...ntergrund.html von Alzi?

[Der schöne Günther]

Hat sich mit dem neuen

Delphi-Quellcode:

System.Threading

unter XE7 etwas geändert oder geht es immer noch nicht?

[Sir Rufo]

Wenn wir uns darauf einigen können, dass der Thread nur ein Ausführungskontext ist und in dem Kontext soll eine Aufgabe erledigt werden, dann ja, dafür ist dann z.B. der

Delphi-Quellcode:

ITask

(wie passend von der Bezeichnung) da.

Und innerhalb eines

Delphi-Quellcode:

ITask

kann man auch weitere Tasks erzeugen. Alle Tasks kommen in eine Queue und werden dann in irgendeinem Thread-Kontext abgearbeitet.

[Der schöne Günther]

Aber grade das will ich ja nicht: Irgendein Thread.

Ich habe einen TThread, der hat irgendwann Daten berechnet/gesammelt. Mit denen soll in einem anderen Thread gearbeitet werden. Ich habe auf die Schnelle mal das hier hingeklatscht:

Delphi-Quellcode:

   TWorkThread = class abstract(TThread)
      private var
         workQueue: TThreadedQueue<TProc>;

      protected
         procedure Execute(); override;

      public
         constructor Create();
         destructor Destroy(); override;

         procedure pushWork(const proc: TProc); virtual;
   end;

{ TWorkThread }

constructor TWorkThread.Create();
begin
   inherited Create(True);
   workQueue := TThreadedQueue<TProc>.Create();
end;

destructor TWorkThread.Destroy();
begin
   workQueue.Free();
   inherited;
end;

procedure TWorkThread.Execute();
const
   sleepIntervalMs = 500;
var
   waitResult:   TWaitResult;
   workItem:   TProc;
begin
   Write('worker Thread ID is ');
   Write(TThread.CurrentThread.ThreadID);
   Write(sLineBreak);

   counter := 0;

   while not Terminated do begin
      waitResult := workQueue.PopItem(workItem);
      if (waitResult = TWaitResult.wrSignaled) then workItem();

      // Und jetzt den Kram, den der Thread eigentlich vorhatte...

      sleep(sleepIntervalMs);
   end;
end;

procedure TWorkThread.pushWork(const proc: TProc);
begin
   if not Assigned(proc) then Exit;
   workQueue.PushItem(proc);
end;

So einfach kann es doch sein, oder?

[Sir Rufo]

Zuerst:

Du willst keinen Thread der sammelt, noch einen der berechnet!

Da gibt es eine Aufgabe des Sammelns und des Berechnens und diese beiden Aufgaben sollen in einem eigenen Thread-Kontext laufen.

Ist das ungefähr getroffen?

[Sir Rufo]

Ganz einfach dargestellt sowas?

Delphi-Quellcode:

TTask.Create( 
  procedure
  var
    LData : TDataContainer;
  begin
    while not Aufhören do
    begin
      if DatenGefunden( LData ) then
        TTask.Create(
          procedure
          begin
            Verarbeite( LData );
          end );
    end;
  end );