Hallo zusammen!

Was ich im Moment über den Ablauf von Threads weiß, hält sich leider noch in zu engen Schranken. Bisher benutze ich sie in der Art, dass ich ein Objekt meiner Threadklasse erzeuge, welches dann ein einziges Mal die Execute-Methode durchlaufen lässt und sich anschließend wieder zerstört(FreeOnTerminate).

Nun weiß ich zum Beispiel nicht, ob es effizient ist, genau auf diese Art und Weise viele Aufgaben pro Sekunde durch solche Threadobjekte erledigen zu lassen.

Ist es beispielsweise möglich, einen Thread ein einziges Mal zu erzeugen und dann quasi immer wieder warten zu lassen, bis er etwas zu tun hat?

Danke

Na klar ist das möglich, indem du einfach dein Threadproc irgendwie auf die Art implementierst:

markieren

Delphi-Quellcode:

while not Abbruchbedingun do begin
  // Prüfen obs was zu tun gibt und wenn ja dann tus
  Sleep(0) //oder auch andere Intervalle, je nachdem wie oft eben Daten zum verarbeiten anfallen
end;

Und die Abbruchbedingung wird eben genau dann erfüllt, wenn du den Abbruch veranlasst

Und ja, es ist unperformant, 1000e Threads immer wieder neu zu erstellen, statt einen 1000 Aufgaben abarbeiten zu lassen!

Zitat von BloodySmartie:

Ist es beispielsweise möglich, einen Thread ein einziges Mal zu erzeugen und dann quasi immer wieder warten zu lassen, bis er etwas zu tun hat?

Ja, ist möglich. Was aber nicht bedeutet, dass deine bisherige Vorgehensweise falsch o.ä. ist.

Wie macht man sowas?

1. Du kannst den Thread mit einer Wait-function (waitforsingleobject, waitformultipleobject,...) warten lassen und ihn mittels Event aufwecken.
2. Du kannst ein Fenster erzeugen (allocatehwnd) und den Thread mittels einer Message wecken, nachdem du ihn mit getmessage oder waitmessage hast schlafen gelegt
3. eine Mischung aus obigen (MsgWaitforMultipleObject)

Ah, interessant. Wenn ich die erste Methode wähle, muss ich das Event dann selbst zur Thread-Klasse hinzufügen? Das einzige Event, dass ich "von Natur aus" finden kann, ist OnTerminate.

Nein, kein VCL-Event, sondern eins von Windows:
TEvent
Event Objects

Vielen Dank, da werd ich mich gleich mal durchforsten.

Vielleicht reicht es dir ja den Thread selbst in den Stopp-Zustand zu versetzen, ala TThread.Suspend (TThread.Resume).

Viele Grüße

Zitat von mirage228:

Vielleicht reicht es dir ja den Thread selbst in den Stopp-Zustand zu versetzen, ala TThread.Suspend (TThread.Resume).

Das ist nicht so gut, da du nie weist, wo der Thread grade ist.

Über Suspend würde ich vielleicht so rangehen:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TMyThread = class(TThread)
  private
  protected
    procedure Execute; override;
  public
    terminate:boolean;
   myData:TMyData;

  end;

procedure TMyThread.Execute;
begin
  while not terminate do
  begin
   doSomething(myData);
   self.Suspend;
  end;
end;

Und im Hauptprogramm:

markieren

Delphi-Quellcode:

//Daten verarbeiten:
myThread.myData:=WhatEver; //Zu verarbeitende Daten setzen
myThread.Resume; //Verarbeitung anstoßen

//Thread beenden:
myThread.terminate:=true
myThread.Resume;

Besonders sauber sieht das aber nicht aus - vor allem müsste ich vielleicht noch über MyThread.Suspended sicherstellen, dass der Thread nicht gerade dann noch beschäftigt ist, wenn ich schon wieder nen neuen Verarbeitungszyklus starten möchte.

Und wenn man an den Thread eine Liste dranhängt mit den zu verarbeitenden Daten?

Einfach in die WorkListe den Auftrag reinpacken egal, ob der Thread läuft oder nicht.
Läuft der Thread, dann arbeitet er alles in der Liste ab.
Läuft der Thread nicht, dann weckt das Einfügen in die WorkList den Thread wieder auf.

Das wäre doch eigentlich die smarteste Lösung

cu

Oliver