Discussion :

[der§en]

Bonjour,

J'ai codé une routine récursive pour parcourir une arborescence de disque dur, qui fonctionne parfaitement.

J'ai voulu voir si en y intégrant des Threads anonymes, cela pouvait améliorer les performances, sauf que les résultats dans ce mode sont complétement délirants.

Si vous aviez des suggestions pour fiabiliser mon projet, je vous en serais reconnaissant.

Voici le code de la fonction ainsi que son appel :

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
 
// Appel de la fonction:
// Edit1.Text contient de dossier de départ.
 
  TThread.CreateAnonymousThread(
    procedure
    begin
      AddThreadedNewNodes(Treeview1.Items, ListBox1.Items, Edit1.Text);
    end
  ).Start;
 
// Code de la fonction:
procedure AddThreadedNewNodes(ATreeNodes: TTreeNodes; AStrings: TStrings; const AFolder: string; AExtension: string = '.txt'; const ANode: TTreeNode = nil);
var
  LNode: TTreeNode;
  LInfo: TSearchRec;
  LNewFolder: string;
  LSubFolder: string;
begin
  LNewFolder := ExtractFileName(AFolder);
  LSubFolder := IncludeTrailingPathDelimiter(AFolder);
 
  LNode := ATreeNodes.AddChild(ANode, LNewFolder);
 
  if FindFirst(LSubFolder + '*', faAnyFile, LInfo) = 0 then
  Begin
    repeat
      if (LInfo.Name <> '.') and (LInfo.Name <> '..') then
      begin
        If (LInfo.Attr And faDirectory) = faDirectory  then
        begin
          TThread.CreateAnonymousThread(
            procedure
            begin
              AddThreadedNewNodes(ATreeNodes, AStrings, LSubFolder + LInfo.Name, AExtension, LNode);
            end
          ).Start;
        end
        else
        begin
          if ExtractFileExt(LInfo.Name) = AExtension then
          begin
            TThread.Synchronize(nil,
              procedure
              begin
                ATreeNodes.AddChild(LNode, LInfo.Name);
 
                AStrings.Add(LSubFolder + LInfo.Name);
              end
            );
          end;
        end;
      end;
 
     until FindNext(LInfo) <> 0;
 
    FindClose(LInfo);
  end;
end;

[pprem]

Bonjour

Les résultats sont probablement conformes à ce que tu as codé.

Les valeurs des choses que tu passes en paramètres sont prises au moment où le code du thread s'exécute, pas au moment de l'appel. Toutes les variables sont à voir comme des pointeurs sur des zones mémoires.

Donc si tu as des trucs qui pointent au même endroit, dont tu changes la valeur quelque part, les autres qui l'utilisent auront la dernière valeur en date.

[Andnotor]

Le problème vient des variables capturées.

Les variables LNode, LInfo et LSubFolder sont déclarées au niveau de AddThreadedNewNodes et sont capturées pour pouvoir être utilisées dans la procédure anonyme du nouveau thread.

Mais ce qui est capturé est une référence sur la variable, pas son contenu !

Ca ne pose pas de problème dans une procédure anonyme "standard" puisqu'elle est synchrone mais dans ton cas, le nouveau thread n'aura pas encore démarré que ces variables auront déjà évolué par la boucle repeat. Résultat, des répertoires sont ignorés (le démarrage du thread n'est pas assez rapide) et d'autres sont traités plusieurs fois (plusieurs threads démarrent au même instant avec la même donnée).

Ce serait plus simple de réaliser cela avec des threads standards et un passage de paramètres à leur création.

Après sur le principe et suivant la taille de ton arborescence, ce sont des centaines de threads qui seront démarrés. Tu n'auras aucun gain et même certainement une dégradation des performances.

Il faudrait plutôt avoir un thread pour parcourir l'arborescence et un certain nombre (fixe, géré par sémaphore) pour valider les fichiers et les synchronisations.

[der§en]

Merci de vos retours, je vais voir ce que cela peut donner avec des Threads standards !