Regelmässig auf vorhandene Dateien prüfen

[DieDolly]

Versuch das mal mit einem Custom-Thread. Der Code ist von hier irgendwo
https://www.delphipraxis.net/181814-...hread-pas.html

Bei diesem Thread brauchst du im Execute keine Schleife. Stattdessen hast du eine ExecuteTimed-Prozedur die alle XYZ-Intervall-Millisekunden aufgerufen wird.
Systembelastung quasi gleich 0.

Delphi-Quellcode:

// Delphipraxis.net: https://www.delphipraxis.net/181814-thread-timer-einbinden-von-timerthread-pas.html
unit Shared.Thread.CustomThread;

interface

uses
 System.Classes, System.SyncObjs;

const
 TIMERTHREAD_INTERVAL_DEFAULT = 1000;
 TIMERTHREAD_ENABLED_DEFAULT = True;

type
 TCustomThread = 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;
  procedure TerminatedSet; override; // ACHTUNG! Das gibt es erst ab Delphi XE2
 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

{TCustomThread}

constructor TCustomThread.Create;
begin
 FCS := TCriticalSection.Create;
 FEvent := TEvent.Create(nil, False, False, '');

 inherited Create(False);

 FInterval := TIMERTHREAD_INTERVAL_DEFAULT;
 FEnabled := TIMERTHREAD_ENABLED_DEFAULT;
end;

destructor TCustomThread.Destroy;
begin
 inherited;

 FEvent.Free;
 FCS.Free;
end;

procedure TCustomThread.Execute;
var
 LInterval: Cardinal;
begin
 inherited;

 while not Terminated do
  begin
   if Enabled then
    LInterval := Interval
   else
    LInterval := INFINITE;

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

procedure TCustomThread.ExecuteTimed;
begin

end;

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

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

procedure TCustomThread.SetEnabled(const Value: Boolean);
begin
 FCS.Enter;
 try
  if Value <> FEnabled then
   begin
    FEnabled := Value;
    FEvent.SetEvent;
   end;
 finally
  FCS.Leave;
 end;
end;

procedure TCustomThread.SetInterval(const Value: Cardinal);
begin
 FCS.Enter;
 try
  if Value <> FInterval then
   begin
    FInterval := Value;
    FEvent.SetEvent;
   end;
 finally
  FCS.Leave;
 end;
end;

procedure TCustomThread.TerminatedSet;
begin
 inherited;

 FEvent.SetEvent;
end;

end.

Von dieser Unit leitest du dir dann deine eigenen Threads einfach ab.

Delphi-Quellcode:

unit MyThread;

interface

uses
 ...,

 MyustomThread;

type
 TMyThread = class(TCustomThread)
 private
  {Private-Deklarationen}
 protected
  procedure ExecuteTimed; override;
 public
  {Public-Deklarationen}
  constructor Create;
 end;

implementation

constructor TMyThread.Create;
begin
 inherited Create;

 Interval := 5000; // rufe alle 5 Sekunden ExecuteTimed auf
 Enabled := True;
end;

procedure TMyThread.ExecuteTimed;
begin

end;

end.