hallo,

ich habe bereits im forum gesucht (auch etwas "ungefähres" gefunden) aber nicht das richtige.

ich versuche gerade eine art "überwachungsprozedur" zu schreiben. diese prüft die uhrzeit und guckt ob diese einen entsprechenden wert in der zukunft bereits erreicht hat.

hiermier starte ich meinen thread:

zusammenfalten · markieren

Delphi-Quellcode:

type
 TMyThread = procedure;

var
 ThreadHandle: THandle;

procedure TForm1.StartThread(Thread: TMyThread);
var
 ThreadID: DWORD;
begin
 ThreadHandle := BeginThread(nil, 0, TFNThreadStartRoutine(@Thread), nil, CREATE_SUSPENDED, ThreadID);

 if ThreadHandle <> 0 then
  begin
   SetPriorityClass(GetCurrentProcess, IDLE_PRIORITY_CLASS);
   SetThreadPriority(ThreadHandle, THREAD_PRIORITY_IDLE);

   ResumeThread(ThreadHandle);
  end;
end;

und meine überwachungsprozedur sieht so aus (ich verwende gewiss kein TThread!)

zusammenfalten · markieren

Delphi-Quellcode:

procedure watcher(iNextRun: LongInt);
var
 bTerminated: Boolean;
begin
 bTerminated := False;

 while not bTerminated do
  begin
   if DateTimeToUnix(now) = iNextRun then
    bTerminated := True;
  end;

 refreshListView;
// hier ist der thread nun am ende!
// aber auch durch aufruf von "StartThread" in der prozedur "refreshListView" wird kein neuer thread gestartet
end;

procedure watcherA;
begin
 // iNextRunA ist ein Integer, hat nichts zu bedeuten
 watcher(iNextRunA);
end;

in der prozedur "refreshListView" steht u.a. folgendes:

markieren

Delphi-Quellcode:

iNextRunA := 123; // hier wird eigentlich ein timestamp, welcher sich in der zukunft befindet, übergeben
StartThread(watcherA);

warum funktioniert das nicht?

Du triffst den richtigen Zeitpunkt vermutlich nicht genau (schon gar-nicht mit Idle-Priorität).

markieren

Delphi-Quellcode:

  begin
   if DateTimeToUnix(now) >= iNextRun then // <- so kann das klappen
    bTerminated := True;
  end;

wenn ich
Form1.StartThread(watcherA); innerhalb des threads aufrufe, funktioniert es, aber er startet und beendet mir dann gefühlte zehn threads. lass ich diese zeile weg, wird der thread nie neu aufgerufen. selbst nicht, wenn es so in der prozedur refreshListView steht.

kann denke ich geschlossen werden, da lösung gefunden

das ständige neustarten der threads war unsinnig, da die doch eh jederzeit gebraucht werden.
die variable iNext setze ich nun innerhalb des threads nach oben (jetztige zeit + 10 sekunden um beispiel).
so habe ich einen fortlaufenden prozess.

ich merke gerade dass mein vorhaben sehr ins schwanken gerät.

durch die threads (mindestens einer, maximal "n") schießt es die cpu-auslastung sehr hoch.

wie kann man sonst eine art "prüfe ob uhrzeit X erreicht ist"-funktion realisieren, wenn nicht mit threads?

Hallo,

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

Warum nutzt Du keinen Timer (TTimer)?

Grüße
Klaus

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