wenn die Zeit noch nicht erreicht ist, dann kannst Du den Thread ja eine gewisse Zeit schlafen legen (sleep(zielzeitInSekunden - nowInSekunden)). das werde ich direkt mal ausprobieren.

es geht hier um dynamisch erzeugte "objekte" die überwacht werden. ich möchte nur ungern hundert timer erstellen.


folgendes habe ich nun (kurzfassung):

zusammenfalten · markieren

Delphi-Quellcode:

procedure watcher(iNextRun: LongInt);
var
 // Variablen Deklaration
begin
 iSleep := iNextRun - DateTimeToUnix(now); // zeit errechnen, welche es bis zum "countdown" ist
 if iSleep < 0 then // sicherheitshalber prüfen, ob der wert positiv ist
  iSleep := 1;

 while True do // ungehindert (hoffe ich ja) und unendlich lange (bis programmende) ..
  begin
   Sleep(iSleep * 1000); // schlafe exakt die zeit, welche oben als "countdown" genannt wurde

   if DateTimeToUnix(now) >= iNextRun then // ist der zeitpunkt erreicht dann..
    begin
     //.. führe noch mehr anweisungen aus

     // danach fängt der code wieder oben bei sleep() an
    end;
  end;
end;

von der cpu-belastung her ist es nun perfekt. vorher 13% (pro thread), nun maximal 1%.

Vorallem in Bezug auf XE2 würde ich eher zu der TThread-Klasse empfehlen.
Weniger nahezu direkt auf die WinAPI loszugehn.
Und derartige TFNThreadStartRoutine(@Thread) unsichere Typecastes würde ich besser auch noch vermeiden.

Das Mehr an OOP kann ja nicht Schaden und eine unbehandelte Exception in der Threadprozedur würde nicht gleich die ganze Anwendung zum verrecken bringen.
Windows beendet Programme, wenn irgendein Thread mit einer Exception beendet wird, aber die TThread-Klasse fängt sowas netter Weise ab.

Test:

zusammenfalten · markieren

Delphi-Quellcode:

function MyThreadFunc(Parameter: Pointer): Integer;
begin
  raise Exception.Create('Fehler');
end;

procedure TForm1.FormCreate(Sender: TObject);
var
  ThreadID: LongWord;
begin
  BeginThread(nil, 0, MyThreadFunc, 0, NORMAL_PRIORITY_CLASS, ThreadId);
end;

Die neue TThread-Klasse bietet auch die Möglichkeit eine Prozedur oder anonyme Methode als Thread laufen zu lassen, also innerhalb einer vordefinierten TThread-Instanz, ohne daß man selber von TThread ableiten muß.



Tipp:
Wozu eigentlich das DateTimeToUnix?
Sleep und UnixTime passt logisch gesehn nicht wirklich zusammen.
- Sleep = Dauer in Millisekunden
- UnixTime = Zeit seit Datum in Sekunden

Nimmt man z.B. iNextRun als TDataTime, dann könnte man es z.B. so machen

markieren

Delphi-Quellcode:

Sleep(MilliSecondsBetween(Now, iNextRun));

// oder notfalls

if iNextRun > Now then
  Sleep(MilliSecondsBetween(Now, iNextRun));

Also ich weiss nicht, mit den Standardtemplates geht das doch 1-fix-drei

Semaphore verwenden (oder ein anderes Synchronisationsobjekt). Vielleicht geht auch ein Sleep (performancetechnisch).
Dann, 1x pro Sekunde prüfen, ob es an der Zeit ist, zu arbeiten. Wenn nicht, weiterschlafen.

markieren

Delphi-Quellcode:

Procedure TMyTimerThread.Execute;
Begin
  While Not Terminated Do begin
    Sleep(OneSecond);
    If Now>TaskTimeToStart then begin
      DoTheJob;
      Terminate;
    End
  End
End;

So würde ich das umsetzen und mir weiter keine Gedanken machen.

Denn mit o.g. Code kann ich den TMyTaskThread auch abbrechen, was imho bei einem langen Sleep nicht geht.

Abbrechen: Statt einem Sleep ein Event.
WaitEvent mit TimeOut, wobei das TimeOut das Sleep darstellt und das Event zum Abbrechen genutzt wird.

z.B. siehe Delay