Discussion :

[ouiouioui]

Bonjour, j'ai un thread qui me sert a afficher un popup avec un message personnalisé et d'autre détails.

l'idée je crée mon thread et en boucle il regarde un array si il y a une entrée il affiche la popup et supprime l'entrée de l'array.

comme sa si j'insère 3 entrées dans l'array il affiche les popups à la suite et pas en même temps.

le problème, comment éviter d'accéder à l'array pour ajouter une entré pendant que le thread supprime une entré?
sachant que j'ajoute des entrées depuis plusieurs autres threads

utiliser:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
var
CriticalSection : TCriticalSection;
begin
CriticalSection :=TCriticalSection.Create; // Initialisation
CriticalSection.Enter; // entrée dans la section critique
…//Code à exécuter de manière critique
CriticalSection.Leave; // Sortie de la section critique
CriticalSection.Free; // libération de l’objet

et mettre ma fonction d'insertion et de suppression entre des sections critique? j'ai tiré l'exemple d'ici: http://lberne.developpez.com/delphi/...us_threads.pdf les mutex c'est mieux? J'ai pas tout compris je crois

ou alors il y mieux comme façon de faire pour gérer mes popups?

Merci pour votre aide.

ah et dernière question
je met un bouton sur mon aplication avec:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
  AlertMsg := TThreadAlertMsg.Create(false);
  AlertMsg.FreeOnTerminate := true;
 
AlertMsg.AddAlert;
 
  AlertMsg.Terminate;

et dans addalert je met un sleep(5000);
et du coup c'est l'application qui freeze et pas le thread
donc la méthode appelé est executé dans le thread appelant et pas celui contenant la méthode c'est sa?

[ouiouioui]

bonjour, toujours personne pour m'aider? Je vois pas comment procéder proprement

je me suis peut-être mal expliqué, désolé.

je cherche à créer un thread qui affiche un message lorsque un thread le demande, et si plusieurs thread demande en même temps que sa crée pas de violations d'accès mais mettre le message en attente pour affichage après l'autre.

remarque c'est pas plus clair quand je relis

merci de m'avoir lu

[LeGEC]

Salut,

Je ne suis pas expert en threads, et je ne sais pas quels sont les avantages et inconvénients, en terme de performances, des différentes méthodes, mais dans ton premier message, tu as à peu près donné la réponse à ta question :

le principe pour lire/écrire de manière sûre dans une zone partagée est de protéger les accès par un sémaphore :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
//délcarer un sémaphore commun à tout le monde
 
//pour ajouter un message :
prendre(sémaphore);
ajouter message dans la file d'attente;
relâcher(sémaphore);

Une sectiuon critique agit exactement comme un sémaphore.
Par rappport au code que tu as mis : il ne faut pas créer une section critique à chaque fois, il faut que la section critique soit commune à tous les threads.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
//au moment où tu lances ton traitement :
   ...
   FVerrouAlerte := TCriticalSection.Create;
   ...
 
 
//au moment où tu crées tes threads :
   ...
   ThreadCalcul := TMaClasseThreadClacul.Create(true); //ou tu peux aussi passer FVerrouAlerte au constructeur de ta classe thread
   ThreadCalcul.VerrouAlerte := FVerrouAlerte;
   ThreadCalcul.Resume;
   ...
 
//dans le code de TMaClasseThreadClacul :
//si FVerrou est un champ de la classe TMaClasseThreadClacul qui contient la section critique passée ci-dessus
  procedure TMaClasseThreadCalcul.EnvoyerAlerte( const AMsg : string );
  begin
    FVerrou.Acquire; //ou FVerrou.Enter, la doc dit que ça fait la même chose
    ... //rajouter AMsg dans la liste des messages
    FVerrou.Release; //ou FVerrou.Leave
  end;
 
 
//dans le code de TThreadAlert :
  procedure TThreadAlert.AfficherUnMessage;
  begin
    FVerrou.Acquire;
    //s'il y a un message, l'afficher
    FVerrou.Release;
  end;

L'important est que ce soit la même section critique pour tout le monde. A part ça, tu avais le principe.

dans addalert je met un sleep(5000);

Le code exécuté par le thread est en fait le code de la méthode Execute de ton TThread. C'est dans Execute (ou dans une des fonctions appelées depuis Execute) que tu dois mettre le sleep :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
type
  TThreadAlert=class(TThread)
    procedure Execute; override;
  end;
 
  procedure TThreadAlert.Execute;
  begin
    while not Terminated do
    begin
      if nbMsg = 0 then sleep(5000);
      if nbMsg <> 0 then AfficherUnMessage;
    end;
  end;

ou un truc du genre.

Tu peux relire le pdf que tu cites, il est assez clair et résume bien les principaux moyens de faire ce genre de choses.

En espérant que ces indications te seront utiles,
*LeGEC*

[Franck SORIANO]

LeGEC a très bien répondu à tes question.

Je ferais juste une remarque par rapport à :

Tu peux relire le pdf que tu cites, il est assez clair et résume bien les principaux moyens de faire ce genre de choses.

Oublie complètement ce qui est dit dans le Pdf sur les sections critiques. C'est complètement faux !
Sous windows, il n'est pas possible de stopper l'exécution des autres threads du processus.
Une section critique n'est rien d'autre qu'un Mutex spécialement optimisé pour protéger des accès brefs à une ressource partagée (à l'intérieur d'un même processus).

Si tu utilises un sémaphore ou un mutex et qu'un thread tente d'accéder à une ressource qui est en cours d'utilisation (par exemple, tu es en train de supprimer le message que tu viens d'afficher du tableau), le thread en question va s'endormir et attendre que windows le réveil lorsque la ressource sera disponible.
Hors si l'accès à la ressource partagé est très bref (supprimer un élément d'un tableau c'est vraiment pas long...), le temps nécessaire pour endormir et reveiller le thread sera très largement supérieur au temps qu'il faudrait attendre pour que la ressource ne se libère... (le tableau sera disponible alors que le thread sera toujours en train de s'endormir).

Avec une section critique, si la ressource n'est pas disponible au moment où tu tentes d'y accéder, la section critique va commencer par attendre un peu en attente active (on boucle dans le vide sans rien faire, d'où la notion de Spin-Lock) que la ressource se libère toute seule. Si elle tarde trop à se libérer, la section critique se mettra en attente de façon classique sur un sémaphore.
Evidemment, une section critique ne présente d'intérêt que sur une machine multi-CPU (multi-processeur, multi-coeurs...), mais ce point est géré automatiquement par le section critique elle même qui se transformera en mutex sur une machine mono CPU.

Sinon question performance tu as dans l'ordre (du plus lent au plus rapide) :
- Le sémaphore pour le cas général.
- Le mutex est un sémaphore optimisé pour faire de l'exclusion mutuelle.
- La section critique qui associe un spin-lock à un mutex pour améliorer les performances pour des accès brefs. Attention contrairement aux deux autres, la section critique ne fonctionne que à l'intérieur du même processus (le spin lock est compteur géré dans la mémoire vive du processus).

[LeGEC]

Merci pour ces précisions que j'aurais bien été incapable de fournir, Mr. Soriano.

*LeGEC*

[ouiouioui]

merci beaucoup, j'ai avancé en suivant les explications voila ou j'en suis, ce n'est pas commentés pour l'instant, ni fini.

ThreadAlertMsg.pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
unit ThreadAlertMsg;
 
interface
 
uses
  Classes {$IFDEF MSWINDOWS} , Windows {$ENDIF}, Dialogs, SyncObjs, fmAlertMsg,
  Controls, SysUtils, MMSystem, Graphics;
 
type
  TAlert = class
    private
      FTitle,
      FText,
      FSound: String;
      FOnTextClick: TNotifyEvent;
      FIcone,
      FSleep: Integer;
    public
      constructor Create(ATitle, AText, ASound: String; AOnTextClick: TNotifyEvent; AIcone, ASleep: Integer);
      property Title: String read FTitle write FTitle;
      property Text: String read FText write FText;
      property Sound: String read FSound write FSound;
      property OnTextClick: TNotifyEvent read FOnTextClick write FOnTextClick;
      property Icone: Integer read FIcone write FIcone;
      property Sleep: Integer read FSleep write FSleep;
  end;
  TAlertList = class(TList)
    private
      function GetItem(AIndex: integer): TAlert;
    public
      constructor Create;
      destructor Destroy; override;
      function Add(AAlert: TAlert): Integer;
      function AddAlert(ATitle, AText, ASound: String; AOnTextClick: TNotifyEvent; AIcone, ASleep: Integer): Integer;
      function IndexOf(AAlert: TAlert): Integer;
      procedure Clear;
      procedure Insert(AIndex: Integer; AAlert: TAlert);
      procedure Delete(AIndex: Integer);
      procedure Remove(AAlert: TAlert);
      property Items[AIndex: Integer]: TAlert read GetItem;
  end;
  TThreadAlertMsg = class(TThread)
  private
    FAlertList: TAlertList;
    GLock : TCriticalSection;
    ActualAlert: TAlert;
    procedure SetName;
    procedure CheckArrayAlert;
    procedure SyncSetAlertData;
    procedure ThreadSleep(Time: Integer);
    procedure DownFormAlert;
    procedure UpFormAlert;
    procedure SyncDownFormAlert;
    procedure SyncUpFormAlert;
    procedure SyncCloseFormAlert;
  public
debugtxt:string;
    procedure AddAlert(ATitle, AText: String; AIcone: String = ''; ASound: String = ''; AOnTextClick: TNotifyEvent = nil; ASleep: Integer = 5000);
    constructor Create;
    destructor Destroy;
procedure debug;
procedure showdbg(txt: String);
  protected
    procedure Execute; override;
  end;
 
implementation
 
{$R sounds.RES}
 
{$IFDEF MSWINDOWS}
type
  TThreadNameInfo = record
    FType: LongWord;     // doit être 0x1000
    FName: PChar;        // pointeur sur le nom (dans l'espace d'adresse de l'utilisateur)
    FThreadID: LongWord; // ID de thread (-1=thread de l'appelant)
    FFlags: LongWord;    // réservé pour une future utilisation, doit être zéro
  end;
{$ENDIF}
 
constructor TAlert.Create(ATitle, AText, ASound: String; AOnTextClick: TNotifyEvent; AIcone, ASleep: Integer);
begin
  FTitle := ATitle;
  FText := AText;
  FSound := ASound;
  FOnTextClick := AOnTextClick;
  FIcone := AIcone;
  FSleep := ASleep;
end;
 
constructor TAlertList.Create;
begin
  inherited Create;
end;
 
destructor TAlertList.Destroy;
begin
  try
    Clear;
  finally
    inherited Destroy;
  end;
end;
 
function TAlertList.Add(AAlert: TAlert): Integer;
begin
  result := inherited Add(AAlert);
end;
 
function TAlertList.AddAlert(ATitle, AText, ASound: String; AOnTextClick: TNotifyEvent; AIcone, ASleep: Integer): Integer;
var
  AAlert: TAlert;
begin
  AAlert := TAlert.Create(ATitle, AText, ASound, AOnTextClick, AIcone, ASleep);
  result := Add(AAlert);
end;
 
function TAlertList.IndexOf(AAlert: TAlert): Integer;
begin
  result := inherited IndexOf(AAlert);
end;
 
procedure TAlertList.Insert(AIndex: Integer; AAlert: TAlert);
begin
  inherited Insert(AIndex, AAlert);
end;
 
procedure TAlertList.Delete(AIndex: integer);
begin
  Items[AIndex].Free;
  inherited Delete(AIndex);
end;
 
procedure TAlertList.Remove(AAlert: TAlert);
begin
  Items[IndexOf(AAlert)].Free;
  inherited Remove(AAlert);
end;
 
function TAlertList.GetItem(AIndex: Integer): TAlert;
begin
  result := TAlert(inherited Items[AIndex]);
end;
 
procedure TAlertList.Clear;
begin
  while inherited Count > 0 do
    Delete(0);
end;
 
{ TThreadAlertMsg }
 
procedure TThreadAlertMsg.SetName;
{$IFDEF MSWINDOWS}
var
  ThreadNameInfo: TThreadNameInfo;
{$ENDIF}
begin
{$IFDEF MSWINDOWS}
  ThreadNameInfo.FType := $1000;
  ThreadNameInfo.FName := 'ThreadAlertMsg';
  ThreadNameInfo.FThreadID := $FFFFFFFF;
  ThreadNameInfo.FFlags := 0;
  try
    RaiseException( $406D1388, 0, sizeof(ThreadNameInfo) div sizeof(LongWord), @ThreadNameInfo );
  except
  end;
{$ENDIF}
end;
 
constructor TThreadAlertMsg.Create;
begin
  inherited Create(False);
  FreeOnTerminate := true;
  FAlertList := TAlertList.Create;
  GLock := TCriticalSection.Create;
end;
 
destructor TThreadAlertMsg.Destroy;
begin
  inherited Destroy;
  FAlertList.Clear;
  FAlertList.Free;
  GLock.Free;
end;
 
procedure TThreadAlertMsg.Execute;
begin
  SetName;
  CheckArrayAlert;
end;
 
procedure TThreadAlertMsg.CheckArrayAlert;
var
  Time: Integer;
begin
  repeat
    ActualAlert := nil;
    //Code ne devant être exécuté que par un thread à la fois
    GLock.Acquire;
    try
      if FAlertList.Count > 0 then
      begin
        ActualAlert := TAlert.Create(FAlertList.Items[0].Title, FAlertList.Items[0].Text, FAlertList.Items[0].Sound, FAlertList.Items[0].OnTextClick, FAlertList.Items[0].Icone, FAlertList.Items[0].Sleep);
        FAlertList.Delete(0);
      end;
    finally
      GLock.Leave;
    end;
    //si alert il y a montrons la
    if ActualAlert <> nil then
    begin
      // mettons les details a afficher en synchronizant car on modif une form
      Synchronize(SyncSetAlertData);
      UpFormAlert;
      ThreadSleep(ActualAlert.Sleep);
      DownFormAlert;
      Synchronize(SyncCloseFormAlert);
      ActualAlert.Free;
    end;
    // attendons 1 sec avant de regarder si nouvelle alert il y a
    Time := 1000;
    while (not Terminated) and (Time > 1) do
    begin
      Dec(Time, 100);
      Sleep(100);
    end;
  until Terminated;
end;
 
procedure TThreadAlertMsg.UpFormAlert;
begin
  // tant que le programme est ok on fait monter la popup jusqu'a sa position normal
  while (not Terminated) and (AlertMsg.Top > AlertMsg.MaxTop) and (AlertMsg.Visible = True) do
  begin
    Synchronize(SyncUpFormAlert);
    Sleep(15);
  end;
end;
 
procedure TThreadAlertMsg.SyncUpFormAlert;
begin
  // on fait monter la form nommé alertmsg par pas
  AlertMsg.Top := AlertMsg.Top - 3;
  AlertMsg.Height := AlertMsg.Height + 3;
end;
 
procedure TThreadAlertMsg.DownFormAlert;
var
  MinTop: Integer;
begin
  // calcul de la position ou a popup est réduite au max
  MinTop := AlertMsg.MaxTop + AlertMsg.MaxHeight;
  // tans que le programme tourne on reduit par pas jusqu'a la taille mini
  while (not Terminated) and (AlertMsg.Top < MinTop) and (AlertMsg.Visible = True) do
  begin
    Synchronize(SyncDownFormAlert);
    Sleep(15);
  end;
end;
 
procedure TThreadAlertMsg.SyncDownFormAlert;
begin
  AlertMsg.Top := AlertMsg.Top + 3;
  AlertMsg.Height := AlertMsg.Height - 3;
end;
 
procedure TThreadAlertMsg.ThreadSleep(Time: Integer);
begin
  while (not Terminated) and (Time > 1) and (AlertMsg.Visible = True) do
  begin
    Dec(Time, 100);
    Sleep(100);
  end;
end;
 
procedure TThreadAlertMsg.SyncCloseFormAlert;
begin
  AlertMsg.Visible := false;
end;
 
procedure TThreadAlertMsg.SyncSetAlertData;
var
  p: Pointer;
  h: THandle;
begin
  with AlertMsg do
  begin
    Caption := ActualAlert.Title;
    TextLbl.Caption := ActualAlert.Text;
    if ActualAlert.Icone <> 0 then
    begin
      IconsList.GetIcon(ActualAlert.Icone - 1, Icon); // Pour afficher la nouvelle
    end
    else
    begin
      Icon := nil;
    end;
    // CONFIGURATION DE LA PROCEDURE APPELEE LORS D'UN CLIC EVENTUEL SUR LE MESSAGE
    if Assigned(ActualAlert.OnTextClick) then // Si une procédure est désignée...
    begin
      TextLbl.Cursor := crHandPoint; // On change le curseur
      TextLbl.OnClick := ActualAlert.OnTextClick; // On assigne la procédure à l'événement du clic
    end
    else
    begin // Sinon...
      TextLbl.Cursor := crDefault; // On rétablit le curseur
      TextLbl.OnClick := nil; // On ne donne pas suite à l'événement de clic
    end;
    Height := 0;
    Top := AlertMsg.MaxTop + AlertMsg.MaxHeight;
    Visible := true;
  end;
  // si il y a un son
  if ActualAlert.Sound <> '' then
  begin
    // si c'est beep on beep
    if AnsiLowerCase(ActualAlert.Sound) = 'beep' then
      Beep // Beep si demandé
    // si pas d'extension et pas beep c'est un nom de ressource .wav
    else if AnsiPos('.wav', ActualAlert.Sound) = 0 then
    begin
      Try
        H := LoadResource(0, FindResource(0, PChar(ActualAlert.Sound), 'WAV'));
        P := LockResource(H);
        sndPlaySound(p, SND_ASYNC or SND_MEMORY);
      Finally
        UnLockResource(H);
//        FreeResource(H);
      End;
    end
    else // pas beep et a .wav donc si le fichiers exists on le joue
      if FileExists(ActualAlert.Sound) then
        sndPlaySound(PChar(ActualAlert.Sound), SND_ASYNC);
  end;
end;
 
procedure TThreadAlertMsg.debug;
begin
  showmessage(debugtxt);
end;
 
procedure TThreadAlertMsg.showdbg(txt: String);
begin
  debugtxt := txt;
  synchronize(debug);
end;
 
procedure TThreadAlertMsg.AddAlert(ATitle, AText: String; AIcone: String = ''; ASound: String = ''; AOnTextClick: TNotifyEvent = nil; ASleep: Integer = 5000);
var
  Icone: Integer;
begin
  AIcone := AnsiLowerCase(AIcone);
  if AIcone = '' then Icone := 0
  else if AIcone = 'info' then Icone := 1
  else if AIcone = 'question1' then Icone := 2
  else if AIcone = 'question2' then Icone := 3
  else if AIcone = 'warning1' then Icone := 4
  else if AIcone = 'warning2' then Icone := 5
  else if AIcone = 'quit' then Icone := 6
  else if AIcone = 'stop' then Icone := 7
  else if AIcone = 'go' then Icone := 8
  else if AIcone = 'secure' then Icone := 9
  else if AIcone = 'validate' then Icone := 10
  else if AIcone = 'search' then Icone := 11
  else if AIcone = 'sendmail' then Icone := 12
  else if AIcone = 'newmail' then Icone := 13
  else if AIcone = 'user' then Icone := 14
  else Icone := 0;
  //Code ne devant être exécuté que par un thread à la fois
  GLock.Acquire;
  try
    FAlertList.AddAlert(ATitle, AText, ASound, AOnTextClick, Icone, ASleep);
  finally
    GLock.Leave;
  end;
end;
 
end.

fmAlertMsg.pas

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
unit fmAlertMsg;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls, StdCtrls, Buttons, ImgList;
 
type
  TAlertMsg = class(TForm)
    IconsList: TImageList;
    TextLbl: TLabel;
    procedure FormCreate(Sender: TObject);
  public                                  
    MaxTop,
    MaxHeight: Integer;
  end;
 
var
  AlertMsg: TAlertMsg;
 
implementation
 
{$R *.dfm}
 
// INITIALISATION DES PARAMETRES
procedure TAlertMsg.FormCreate(Sender: TObject);
var
  Rect: TRect;
begin
  DoubleBuffered := true;                                   // On évite le scintillement
  Left:= Screen.Width - ClientWidth - 20;                    // La form se tiendra pile à droite de l'écran
  SystemParametersInfo(SPI_GETWORKAREA, 0, @Rect, 0);       // On récupère la hauteur de la barre des tâches
  MaxTop := Screen.Height - (Screen.Height - Rect.Bottom) - Height - 35;
  MaxHeight := Height;
end;
 
end.

dans mes use de ma form:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

ThreadAlertMsg

dans mon tform public:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

    ThreadAlertMsg: TThreadAlertMsg;

dans mon form create:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  ThreadAlertMsg := TThreadAlertMsg.Create;

dans mon form destroy:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  ThreadAlertMsg.Terminate;

mon bouton test:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
procedure TMain.Button1Click(Sender: TObject);
begin
  ThreadAlertMsg.AddAlert('aaaaaaa', 'fvgfggvggg    ggghgh         fvbvfvb hg', 'info', 'C:\WINDOWS\Media\Windows XP Démarrage.wav', nil, 1000);
  ThreadAlertMsg.AddAlert('aaaaaaa', 'fvgfggvggg    ggghgh   fvbvfvb hg', '', 'beep', nil, 10000);
  ThreadAlertMsg.AddAlert('aaaaaaa', 'fvgfggvggg    ggghgh   fvbvfvb hg', 'secure', '', nil, 10000);
  ThreadAlertMsg.AddAlert('aaaaaaa', 'fvgfggvggg    ggghgh   fvbvfvb hg', 'warning1', '', nil, 1000);
  ThreadAlertMsg.AddAlert('aaaaaaa', 'fvgfggvggg    ggghgh         fvbvfvb hg', '', '', nil, 1000);
  ThreadAlertMsg.AddAlert('aaaaaaa', 'fvgfggvggg    ggghgh         fvbvfvb hg', '', '', nil, 1000);
end;

je vais mettre le thread en suspend lorsque il y a plus d'alerte et le réveiller si il l'est pas lors d'ajout d'alertes, car la il vérif toutes les 1sec si alerte il y a.

je suis preneur de tout conseil, mais surtout sur la section critique qui doit pas etre au bon endroit si j'ai bien compris vos messages. Merci