Ich habe bislang oft Sachen in den Hauptthread geschoben. Entweder mittels TThread.Synchronize(nil, meineProzedur); oder 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 ExecuteQueuedMethods () erwartet dass ich in meiner Execute-Prozedur ausführen kann, aber das einzige was ich finden konnte war das genannte 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.

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

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 )

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.

Zitat von Uwe Raabe:

musst du halt selbst programmieren

Zitat von himitsu:

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

Schade.

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

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

Hat sich mit dem neuen System.Threading unter XE7 etwas geändert oder geht es immer noch nicht?

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 ITask (wie passend von der Bezeichnung) da.

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

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:

zusammenfalten · markieren

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?

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?

Ganz einfach dargestellt sowas?

zusammenfalten · markieren

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 );