wait prozedur bewirkt vollständige cpu auslastung

[JonnyGuitar]

habe ich gerade versucht, dass geht *g*. aber leider bringt der code:

Delphi-Quellcode:

procedure Delay(Milliseconds: Integer);
{by Hagen Redmann}
var
  Tick: DWORD;
//  Event: THandle;
begin
//  Event := CreateEvent(nil, False, False, nil);
  try
    Tick := GetTickCount + DWORD(Milliseconds);
    while (Milliseconds > 0) and
      (MsgWaitForMultipleObjects(2, hndlArr, False, Milliseconds, QS_ALLINPUT) <> WAIT_TIMEOUT) do
    begin
      Application.ProcessMessages;
      Milliseconds := Tick - GetTickCount;
    end;
  finally
//    CloseHandle(Event);
  end;
end;

auch wieder volle cpu auslastung


mfg Jonny

[Luckie]

Ruf doch einfach mal in deinem ursprüngluichen Code Sleep(1) auf.

[JonnyGuitar]

moin luckie,

trotz sleep(1) immer noch volle cpu auslastung...


mfg Jonny

[Flocke]

Zwei Fragen:
1. Rufst du die Routine in einem Thread auf?
2. Warum gibst du in einem Beispiel den aktuellen Thread (GetCurrentThread) als das Objekt an, auf das gewartet werden soll?

[negaH]

@Jonny:

Ist das noch der gleiche Code den du verwendest ? Nein: du kommentierst Zeilen aus die die Funktion vollständig verändern.

Delphi-Quellcode:

procedure Delay(Milliseconds: Integer);
{by Hagen Reddmann}
var
  Tick: DWORD;
  Event: THandle;
begin
  Event := CreateEvent(nil, False, False, nil);
  try
    Tick := GetTickCount + DWORD(Milliseconds);
    while (Milliseconds > 0) and
      (MsgWaitForMultipleObjects(1, Event, False, Milliseconds, QS_ALLINPUT) <> WAIT_TIMEOUT) do
    begin
      Application.ProcessMessages;
      Milliseconds := Tick - GetTickCount;
    end;
  finally
    CloseHandle(Event);
  end;
end;

So funktioniert das wunderprächtig, in einem normalem Prozess wie angedacht. Das Event so zu benutzen ist essentiell, es ist nämlich ein niemals signalsierendes Event und darauf baut der Code aktiv auf.

Willst du das abändern dann unter 4 Bedingungen:

Delphi-Quellcode:

procedure Delay(Milliseconds: Integer);
var
  Tick: DWORD;
begin
  Tick := GetTickCount + DWORD(Milliseconds);
  while Milliseconds > 0 do
  begin
    case WaitForMultipleObjects(2, hndlArr, False, Milliseconds, QS_ALLINPUT) of
      WAIT_OBJECT_0 +0 :
        begin
          // Event Nummer 1 signalisiert
        end;
      WAIT_OBJECT_1 +1 :
        begin
          // Event Nummer 2 signalisiert
        end;
      WAIT_TIMEOUT:
        begin
          // nothing todo
          Exit;
        end; 
    else
      begin
        // Fehler !! 
      end;
    end; 
    Milliseconds := Tick - GetTickCount;
  end;
end;

1.) ein Service wie deiner hat keinen Message Queue
2.) MsgWaitFor...() benötigt einen Message Queue, ergo wird WaitForMultipleObjects() benutzt
3.) du musst bei vorzeitiger Rückkehr von WaitFor..() auch die signalisierenden Events abprüfen. Besonders wenn diese Events sich nur manuell zurücksetzen lassen. Du hast ja eben nichts darüber ausgesagt was für Events das sind und wie sie signalisiert/resetet werden
4.) überpüfe nun ob der obige Code permanent in WAIT_OBJECT_0 oder WAIT_OBJECT_0 +1 rein springt. Sollte dies der Fall sein so ist dein Event Handling falsch. Eventuell musst du die Event mit ResetEvent() zurücksetzen.

Alles in allem kann ich dir garantieren das wenn die Events korrekt benutzt werden die CPU Auslastung entsprechend der Häufigkeit des Auslösens der Events absinken wird. Sind diese natürlich permanent signalisiert so beträgt die CPU Auslastung auch 100%.

Der obige Code ist dermaßen trivial das ein Fehler auszuschließen ist. Wenn also die CPU Auslastung immer noch 100% ist so wird es mit großer Wahrscheinlichkeit ein Fehler in deinem restlichen Code sein (den wir ja nicht kennen).

Gruß Hagen

[JonnyGuitar]

so, mit dem letzten code klappt alles hervorragend,

jedoch sind noch 3 veränderungen zu machen:

Delphi-Quellcode:

procedure Delay(Milliseconds: Integer);
var
  Tick: DWORD;
begin
  Tick := GetTickCount + DWORD(Milliseconds);
  while Milliseconds > 0 do
  begin
    case WaitForMultipleObjects(2, @hndlArr, False, Milliseconds) of
      WAIT_OBJECT_0 +0 :
        begin
          // Event Nummer 1 signalisiert
        end;
      WAIT_OBJECT_0 +1 :
        begin
          // Event Nummer 2 signalisiert
        end;
      WAIT_TIMEOUT:
        begin
          // nothing todo
          Exit;
        end;
    else
      begin
        // Fehler !!
      end;
    end;
    Milliseconds := Tick - GetTickCount;
  end;
end;

so liet die prozessorauslastung bei 0% und ich bin glücklich.

vielen dank an alle

mfg Jonny