Polling im TThread

[haentschman]

Danke für deine Antwort. Event...wie meinst du das?

mein Vorschlag:

Delphi-Quellcode:

procedure TWorkerPolling.Execute;
var
  StartCount: Cardinal;
  CurrentCount: Cardinal;
begin
  inherited;
  StartCount:= 0;
  while not Terminated do
  begin
    CurrentCount:= GetTickCount;
    if (CurrentCount - StartCount) > conPollingInterval then // conPollingInterval = 10000
    begin
 
     // auszuführender Code

      StartCount:= CetTickCount;
    end;
    Sleep(100); // für Leerlauf
  end;
end;

...auf die 100 ms "Versatz" kann man verzichten.

Zitat:

wo man 10 Sekunden wartet ob er auslöst

...das Warten ist ja das Problem. Auf der einen Seite sollen die Anweisungen nur alle X Milisekunden ausgeführt werden, auf der anderen Seite soll der Thread von Außen sofort beendbar sein. Ist der Thread gerade in der "Verarbeitung" macht er diese natürlich erst fertig und beendet sich dann sofort weil Terminated von außen gesetzt wurde.

[Namenloser]

Zitat von haentschman:

Event...wie meinst du das?

TEvent

Deine Variante geht natürlich auch, ist aber im Grunde busy-waiting und daher unschöner.

[haentschman]

ok...das nächste Mal drücke ich mich geschickter aus. Events benutzte ich reichlich weil ich weis wie es geht... Nur im Zusammenhang mit Thread und Auslösen / Warten stand ich auf dem Schlauch...

[Uwe Raabe]

Den Event beim Terminate auslösen geht am elegantesten, wenn man DoTerminate überschreibt.

[haentschman]

Zitat:

ist aber im Grunde busy-waiting und daher unschöner.

Der Thread soll ja nur den Codeblock abarbeiten... aber nur alle 10 Sekunden. Den Rest macht er nur im Execute die Schleife. (Leerlauf) Warum ist das unschön? Ein Thread läuft doch sowieso im Execute im Kreis und macht immer das Gleiche.

Zitat:

Den Event beim Terminate auslösen geht am elegantesten, wenn man DoTerminate überschreibt.

Vieleicht ist es ja schon zu spät...Aber ich verstehe nicht wie mir ein Event im überschriebenen DoTerminate beim normalen Abarbeiten im Execute hilft.

[Namenloser]

Zitat von haentschman:

Zitat:

ist aber im Grunde busy-waiting und daher unschöner.

Der Tread soll ja nur den Codeblock abarbeiten... aber nur alle 10 Sekunden. Den Rest macht er nur im Execute die Schleife. (Leerlauf) Warum ist das unschön? Ein Thread läuft doch sowieso im Execute im Kreis und macht immer das Gleiche.

Weil der Thread alle 100ms aufgeweckt wird statt alle 10 Sekunden. Jedes Aufwecken verbrät etwas CPU-Zeit. Dazu kommt noch als weiterer Nachteil die 100ms-Latenz beim Beenden. Letztlich kannst du hier stufenlos zwischen zwei Übeln wählen: kleinere Warteintervalle und damit kleinere Latenz aber dafür höhere CPU-Verschwendung, oder höhere Warteintervalle und damit weniger CPU-Verschwendung aber dafür größere Latenz.

Beides ist aber völlig unnötig, weil das Betriebssystem in Form von Events bereits eine perfekte Lösung anbietet.

[himitsu]

Das einfachste und beste Beispiel, für das eben Genannte, ist die Delay-Funktion von Hagen.

• möglichst wenig CPU-Last, da nichts gemacht wird, ohne daß etwas ansteht
• und wenn etwas ansteht, oder wenn die Zeit abgelaufen ist, dann wird sofort reagiert

[Sir Rufo]

Zitat von Uwe Raabe:

Den Event beim Terminate auslösen geht am elegantesten, wenn man DoTerminate überschreibt.

Öhm, wenn du damit mal nicht auf die Nase fällst, denn DoTerminate wird aufgerufen, wenn das Terminieren (Beenden) beginnt -> die Execute-methode verlassen wurde.

TerminatedSet ist da wesentlich geschickter

[Uwe Raabe]

Zitat von Sir Rufo:

TerminatedSet ist da wesentlich geschickter

Die hatte ich auch eigentlich gemeint - beim Tippen stand der Editor halt grad auf der falschen Methode. Ich weiß nur nicht, ob es die in XE schon gab.

[Sir Rufo]

Das ist mit dem Event gemeint:

Delphi-Quellcode:

unit TimerThread;

interface

uses
  System.Classes,
  System.SyncObjs;

const
  TIMERTHREAD_INTERVAL_DEFAULT = 1000;
  TIMERTHREAD_ENABLED_DEFAULT = True;

type
  TTimerThread = class( TThread )
  private
    FCS : TCriticalSection;
    FEvent : TEvent;
    FInterval : Cardinal;
    FEnabled : Boolean;
    procedure SetInterval( const Value : Cardinal );
    function GetInterval : Cardinal;
    procedure SetEnabled( const Value : Boolean );
    function GetEnabled : Boolean;
  protected
    procedure Execute; override; final;
    procedure ExecuteTimed; virtual;
    // ACHTUNG! Das gibt es erst ab Delphi XE2
    procedure TerminatedSet; override;
  public
    constructor Create;
    destructor Destroy; override;

    property Interval : Cardinal read GetInterval write SetInterval default TIMERTHREAD_INTERVAL_DEFAULT;
    property Enabled : Boolean read GetEnabled write SetEnabled default TIMERTHREAD_ENABLED_DEFAULT;
  end;

implementation

{ TTimerThread }

constructor TTimerThread.Create;
begin
  FCS := TCriticalSection.Create;
  FEvent := TEvent.Create( nil, False, False, '' );
  inherited Create( False );
  FInterval := TIMERTHREAD_INTERVAL_DEFAULT;
end;

destructor TTimerThread.Destroy;
begin

  inherited;
  FEvent.Free;
  FCS.Free;
end;

procedure TTimerThread.Execute;
var
  LInterval : Cardinal;
begin
  inherited;
  while not Terminated do
    begin
      if Enabled then
        LInterval := Interval
      else
        LInterval := INFINITE;

      if FEvent.WaitFor( Interval ) = TWaitResult.wrTimeout
      then
        ExecuteTimed;
    end;
end;

procedure TTimerThread.ExecuteTimed;
begin

end;

function TTimerThread.GetEnabled : Boolean;
begin
  FCS.Enter;
  try
    Result := FEnabled;
  finally
    FCS.Leave;
  end;
end;

function TTimerThread.GetInterval : Cardinal;
begin
  FCS.Enter;
  try
    Result := FInterval;
  finally
    FCS.Leave;
  end;
end;

procedure TTimerThread.SetEnabled( const Value : Boolean );
begin
  FCS.Enter;
  try
    FEnabled := Value;
  finally
    FCS.Leave;
  end;
end;

procedure TTimerThread.SetInterval( const Value : Cardinal );
begin
  FCS.Enter;
  try
    FInterval := Value;
    FEvent.SetEvent;
  finally
    FCS.Leave;
  end;
end;

procedure TTimerThread.TerminatedSet;
begin
  inherited;
  FEvent.SetEvent;
end;

end.

Allerdings gibt es dieses TThread.TerminatedSet erst ab Delphi XE2 und für die Funktion unerlässlich. Einen Workaround für alles kleiner XE2 habe ich gerade nicht zur Hand.