Threads et TEvents

Date de publication : 12/09/2004 , Date de mise a jour : 12/09/2004

Par Adrien Reboisson (reisubar.developpez.com)
 

Cet article présente comment utiliser threads et TEvents pour construire des procédures s'exécutant périodiquement en arrière plan dans vos applications.

I. But recherché

• Créer une classe dérivée de TThread,
• Dans la procédure OnExecute, coder une fonction utilisant Sleep() pour "dormir" un certain temps, puis le code à exécuter, tout cela dans une boucle testant si la valeur Terminated du thread n'est pas à True. Et si tel est le cas, sortir de cette boucle.

delphi
procedure TFooThread.Execute;
begin
  while not Terminated do
  try
     Sleep(30 * 60 * 1000); //"Dormir" 30 minutes
     DoWork(); //Cette méthode contient le code à exécuter
  finally
  end;
end;

II. Utilisation du TEvent

III. Implémentation

I. Définition du thread

• Tout d'abord, il faut ajouter SyncObjs dans la clause uses de votre thread. C'est cette unité de la VCL qui gère les objets de synchronisation (et contient donc TEvent).
• Ensuite, il faut déclarer une propriété privée de type TEvent dans le thread crée. Par convention, on fait précéder d'un "F" les propriétés d'un objet : j'appelerais donc cet événement FEvent.

I. Constructeur du thread

delphi
constructor TEventThread.Create(ACreateSuspended : Boolean);
begin
  FEvent := TEvent.Create(nil, False, False, ''); { Créer l'événement désactivé }
  inherited Create(ACreateSuspended); //appeller la méthode ancètre
end;

III. Destructeur du thread

delphi
destructor TEventThread.Destroy;
begin
  FreeAndNil(FEvent);
  inherited;
end;

IV. La procédure Execute() du thread

delphi
procedure TEventThread.Execute;
var
 LSecondsToWait : Integer;
begin
  LSecondsToWait := 120; { Intervalle d'exécution. Ici, 120 secondes }
  while not Terminated do
  try
     case FEvent.WaitFor(LSecondsToWait * 1000) of
       wrSignaled : Terminate; { Evènement déclenché. Demande de fin de thread. On sort de la boucle }
       wrTimeout : DoWork; { Délai atteint : on exécute la procédure }
     end;
  finally
  end;
end;

V. La procédure Kill() du thread

delphi
procedure TEventThread.Kill;
begin
  FEvent.SetEvent; { L'événement est ainsi activé }
end;

IV. Tests

delphi
var
  Form1: TForm1;
  GEventThread : TEventThread = nil;
  
implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  GEventThread.Kill;
  GEventThread.WaitFor;
  MessageDlg('Thread stoppé.', mtWarning, [mbOK], 0);
end;

initialization
  GEventThread := TEventThread.Create(False);
  GEventThread.Resume;

finalization
  if Assigned(GEventThread) then
    FreeAndNil(GEventThread);
end;

V. TThreadedTimer, une classe réutilisable

• L'intervalle d'exécution sera paramètrable et à préciser dans le constructeur,
• La procédure Terminate sera redéfinie pour permettre automatiquement d'activer l'événement (le rôle de notre précédente méthode Kill),
• La procédure de gestion des événements étant codée dans la procédure Execute du TThreadedTimer, il a fallu déporter l'endroit où placer le code utilisateur autre part. Le code exécuté est donc maintenant géré via l'événement (au sens de pointeur de méthode) OnTimer que les classes dérivées doivent exploiter.

delphi
type
  TThreadedTimer = class(TThread)
  private
    FEvent : TEvent;  { Evènement interne }
    FInterval : Cardinal; { Intervalle }
    FOnTimer: TNotifyEvent;  { Procédure d'événement à appeller pour exécuter le code }
  protected
    procedure Execute; override;
    procedure DoTimer; { Wrapper pour FOnTimer }
  public
    constructor Create(ACreateSuspended : Boolean; AInterval : Cardinal);  { Constructeur }
    destructor Destroy; override; { Destructeur }
    procedure Terminate; reintroduce; { Procédure de terminaison à nous, redéfinie }
    property Terminated; { réexpose la propriété ancètre }
    property OnTimer : TNotifyEvent read FOnTimer write FOnTimer;  { Propriété 
	   permettant la gestion de l'événement utilisateur FOnTimer }
  end;

implementation

constructor TThreadedTimer.Create(ACreateSuspended : Boolean; AInterval : Cardinal);
begin
  FEvent := TEvent.Create(nil, False, False, ''); { Créer l'événement désactivé }
  FInterval := AInterval; { Mémoriser l'intervalle }
  inherited Create(ACreateSuspended); { Appeller la méthode ancètre }
end;

destructor TThreadedTimer.Destroy;
begin
  FreeAndNil(FEvent); { Détruire l'événement }
  inherited;
end;

procedure TThreadedTimer.DoTimer;
begin
  if Assigned(FOnTimer) then { procédure assignée ?... }
    FOnTimer(Self); { ... alors l'exécuter }
end;

procedure TThreadedTimer.Execute;
begin
  while not Terminated do
  try
     case FEvent.WaitFor(FInterval) of
       wrSignaled : Terminate; { Evènement déclenché. Demande de fin de thread. On sort de la boucle }
       wrTimeout : DoTimer; { Délai atteint : on exécute la procédure }
     end;
  finally
  end;
end;

procedure TThreadedTimer.Terminate;
begin
  FEvent.SetEvent; { Activer l'evénement }
end;

delphi
var
  Form1: TForm1;
  GEventThread : TThreadedTimer = nil;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  { procédure appellée pour arrêter le thread }
  GEventThread.Terminate;
  MessageDlg('Thread stoppé.', mtWarning, [mbOK], 0);
end;

procedure TForm1.DoWork(sender : tobject);
begin
 { code à exécuter dans notre procédure de thread. Attention, ce code est threadé. }
 MessageBox(Handle, pchar('HelloWorld'), nil, 0);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
   { Associer l'événement }
   GEventThread.OnTimer := DoWork;
end;

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  { Terminer le thread si besoin }
  if not GEventThread.Terminated then
    GEventThread.Terminate;
end;

initialization
  GEventThread := TThreadedTimer.Create(False, 10 * 1000); {Toutes les 10 secondes }
  GEventThread.Resume;

finalization
  if Assigned(GEventThread) then
    FreeAndNil(GEventThread);

VI. Remarques