Utilisation de processus sous Delphi : fonctionnement de base.

Comme je l'indiquais dans la première partie de cette série sur les processus : il ne faut désormais bloquer les programmes en aucune manière, que ce soit en utilisation VCL pour Windows pur ou en FMX pour les autres cibles de compilation. Les systèmes d'exploitation n'aiment pas ça, les utilisateurs non plus.

Il faut donc passer les traitements longs ou interruptifs en processus secondaires. Cela oblige à une certaine gymnastique intellectuelle lorsqu'on conçoit nos programmes. Il ne faut en effet plus simplement penser "procédural" (à l'ancienne) ou "événementiel" (depuis Windows et Delphi 1, peut-être même Turbo Vision, j'avoue ne plus me souvenir trop de comment ça fonctionnait), mais "exécution parallèle".

La façon la plus simple pour créer un processus sous Delphi est cette construction :

tthread.CreateAnonymousThread(
  procedure
  begin
  end).Start;

La méthode de classe TThread.CreateAnonymousThread permet de créer un processus anonyme qui exécute le contenu de la procédure passée en paramètre. La méthode retourne un objet TThread qu'il ne faut pas oublier de lancer, d'où le ".Start" final (que j'oublie encore régulièrement malgré l'expérience).

Ce qu'il faut avoir en tête, c'est que les éléments visuels de l'application ne sont disponibles que pour le processus principal. Toute action vers un composant visuel depuis un processus secondaire doit se faire en le synchronisant avec le processus principal. Il existe pour cela la méthode de classe TThread.Synchronize.

Je l'utilise en général sous la forme suivante :

tthread.Synchronize(nil,
  procedure
  begin
  end);

Son premier paramètre correspond à une référence de thread qui peut par exemple être le processus en cours, si on en avait besoin ensuite.

tthread.Synchronize(tthread.CurrentThread,
  procedure
  begin
  end);

Si on place un bouton sur une fiche et qu'on gère son événement onClick, voici ce que tout ceci pourrait donner.

procedure TForm1.Button1Click(Sender: TObject);
begin
  // traitements habituels dans le processus principal
  tthread.CreateAnonymousThread(
    procedure
    begin
      // traitements dans le processus secondaire
      tthread.Synchronize(nil,
        procedure
        begin
          // interruption du processus secondaire pour exécuter ce code dans le processus principal
        end);
      // reprise du traitement secondaire
    end).Start;
  // traitements habituels dans le processus principal
end;

Notez que dans cet exemple le processus anonyme est lancé n'importe où dans le code du processus principal et peut s'exécuter au-delà de la fin d'exécution du clic sur le bouton. C'est tout l'intérêt des processus.

Pour aller plus loin et être opérationnel, il y a maintenant la question des paramètres et variables locales ou globales disponibles dans le processus secondaire.

Pour la faire court, les règles habituelles de visibilité des variables sont les mêmes en ce qui concerne les processus que pour les procédures et fonctions imbriquées les unes dans les autres. Une variable déclarée dans le onClick sera donc accessible par le processus même si l'exécution du onClick se termine. Le compilateur garde la zone mémoire active jusqu'à ce que tous les processus créés dans cet événement soient terminés.

Par extension de cette règle, on peut utiliser "self" dans un processus secondaire créé depuis une méthode d'objet. Il pointera sur l'instance de l'objet ayant entrainé sa création. Je ne le recommande pas pour des raisons de lisibilité du code et de maintenance, mais rien ne vous en empêche.

Attention cependant à un point très important : l'accès concurrent aux objets, variables, flux, fichiers et espaces mémoires en général. Si on a plusieurs processus modifiant la même chose le résultat final peut au mieux générer des erreurs ou au pire des choses incohérentes. Il ne faut pas hésiter à déclarer des MUTEX ou des sections critiques si nécessaire.

Pour finir je vous propose un cas pratique :

  • créez un nouveau projet multi plateforme (donc Firemonkey, même si le principe serait le même en VCL)
  • placez un tButton sur la fiche
  • placez 5 tRectangle sur la fiche
  • placez un tTimer sur la fiche
  • éditez le onCreate de la fiche
  • éditez le onClick du bouton
  • éditez le onTimer du bouton
  • copiez/collez ensuite le code suivant dans votre unité
  • compilez et admirez le travail
unit Unit1;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes,
  System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.Objects,
  FMX.Controls.Presentation, FMX.StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Rectangle1: TRectangle;
    Rectangle2: TRectangle;
    Rectangle3: TRectangle;
    Rectangle4: TRectangle;
    Rectangle5: TRectangle;
    Timer1: TTimer;
    procedure Button1Click(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Déclarations privées }
    procedure traitement(rectangle: TRectangle);
  public
    { Déclarations publiques }
  end;

var
  Form1: TForm1;

implementation

{$R *.fmx}

const
  nb_secondes = 60;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Button1.Enabled := false;
  traitement(Rectangle1);
  traitement(Rectangle2);
  traitement(Rectangle3);
  traitement(Rectangle4);
  traitement(Rectangle5);
  Timer1.Enabled := true;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  Timer1.Interval := 1000;
  Timer1.Tag := nb_secondes;
  Timer1.Enabled := false;
end;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
  if (Timer1.Tag > 0) then
  begin
    Timer1.Tag := Timer1.Tag - 1;
    Button1.Text := Timer1.Tag.ToString;
  end
  else
    Timer1.Enabled := false;
end;

procedure TForm1.traitement(rectangle: TRectangle);
begin
  tthread.CreateAnonymousThread(
    procedure
    var
      couleur: talphacolor;
      i: integer;
    begin
      for i := 1 to nb_secondes * 10 do
      begin
        case random(8) of
          0:
            couleur := talphacolors.red;
          1:
            couleur := talphacolors.orange;
          2:
            couleur := talphacolors.yellow;
          3:
            couleur := talphacolors.green;
          4:
            couleur := talphacolors.blue;
          5:
            couleur := talphacolors.Violet;
          6:
            couleur := talphacolors.Pink;
          7:
            couleur := talphacolors.white;
        else
          couleur := talphacolors.black;
        end;
        tthread.Synchronize(nil,
          procedure
          begin
            rectangle.Fill.Color := couleur;
          end);
        sleep(100); // attente de 0,1 seconde
      end;
    end).Start;
end;

end.

Ce qui donne ceci (en réduisant la durée à 10 secondes) :

La prochaine fois nous verrons comment lancer des processus bloquants sans l'être vraiment, ce qui peut servir lors de la récupération de données provenant d'API en ligne pour l'affichage à l'écran.


A lire aussi

Plutôt INI ou JSON pour stocker vos paramètres ? (21/07/2017)
Calculer et vérifier un checksum pour dialoguer avec l'extérieur (19/07/2017)
Télécharger simplement un fichier via Internet en tâche de fond (10/07/2017)
Calculer un MD5 sous Delphi (04/07/2017)
Les threads et le blocage des écrans (14/06/2017)
Utilisation de processus sous Delphi : fonctionnement de base. (04/06/2017)
Passer un traitement lourd en tâche de fond sans bloquer l'écran (04/06/2017)
Ajouter des chaînes de caractères vides dans un objet JSON (19/05/2017)
Configurer le firewall de McAfee AntiVirus Plus pour utiliser l'App Tethering (28/06/2016)