Discussion :

[benj63]

Ne t'inquiète pas, tu ne me vexes pas !
Je préfère qu'on me réponde, surtout si je dis des âneries !

En fait je souhaite bien utiliser l'héritage pour une bonne raison, mais j'ai du mal m'exprimer.

En fait, la classe TThread ne contient pas assez de propriétés à mon goût. Je souhaite lui ajouter la propriété "Config" et ensuite, je souhaite créér de nouvelles classes dérivées de celle-ci pour les utiliser dans une autre classe (TTimerPlanning).

A priori, je suis parvenu à réaliser tout cela en ne mettant pas d'Execute à la classe dérivée de TThread, mais en mettant un virtual Execute à la classe dérivée de cette dernière.

Explication par l'exemple :

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
// -----------------------------------------------------------
// Classe dérivée de TThread avec une propriété de +
// -----------------------------------------------------------
class TThreadSpeciale : public TThread
{
 public:
        Config *VilleConfig;
 
        __fastcall TThreadSpeciale (bool CreateSuspended, Config *config) : TThread(CreateSuspended)
        {
                VilleConfig = config;
        }
};
 
// -----------------------------------------------------------
// Différentes classes dérivées de TThread1
// -----------------------------------------------------------
class TThread1 : public TThreadSpeciale 
{
 protected:
        virtual void __fastcall Execute()
        {
                Fonction1(...);
        }
 
 public:
        __fastcall TThread1(bool CreateSuspended, Config *config) : TThreadSpeciale(CreateSuspended, config) {}
};
// -----------------------------------------------------------
class TThread2 : public TThreadSpeciale 
{
 protected:
        virtual void __fastcall Execute()
        {
                Fonction2(...);
        }
 
 public:
        __fastcall TThread2(bool CreateSuspended, Config *config) : TThreadSpeciale(CreateSuspended, config) {}
};
// -----------------------------------------------------------
class TThread3 : public TThreadSpeciale 
{
 protected:
        virtual void __fastcall Execute()
        {
                Fonction3(...);
        }
 
 public:
        __fastcall TThread3(bool CreateSuspended, Config *config) : TThreadSpeciale(CreateSuspended, config) {}
};
 
// -----------------------------------------------------------
// Classe TTimerPlanning 
// -----------------------------------------------------------
class TTimerPlanning : public TTimer
{
  public:
        TLabel *Label;                           // Label qui affichera le temps restant
        String TexteLabel;                      // Texte qui sera affiché sur le label. Par exemple, TexteLabel = "Prochain téléchargement dans "
        TThreadSpeciale *Thread;          // Thread qui sera lancé "OnTimer"
 
        vector<unsigned short> PlanningHeure;   
        vector<unsigned short> PlanningMinute; 
 
        __fastcall TTimerPlanning(TComponent *AOwner, vector<unsigned short> planning_heure, vector<unsigned short> planning_minute, TThreadSpeciale *thread);
       __fastcall TTimerPlanning(TComponent *AOwner, vector<unsigned short> planning_heure, vector<unsigned short> planning_minute, TThreadSpeciale *thread, TLabel *label, String texte_label);
};

Ainsi je pourrai déclarer différentes instances de TTimerPlanning avec chacun des différents thread Thread1, Thread2, Thread3 etc... sans avoir à recréer à chaque fois un TTimerPlanning pour chacun des threads !

Tout cela fonctionne (à priori !), mais je souhaiterai néanmoins savoir si c'est correct (notamment le virtual void Execute) et s'il n'y a pas de fuite de mémoire (mon cauchemar).

Merci en tout cas de t'être penché sur mon problème.

[Caine]

C'est correct je pense.

Tu as donc compris que tu n'auras qu'un seul Thread exécuté par chaque enfants de TThread avec ton code.

Heureusement qu'il ny a pas trop de limite en nombre de thread sous Windows

[benj63]

Je te remercie !

Je laisse encore ce sujet un peu ouvert avant de mettre le [résolu], si des fois quelqu'un passait et trouvait une erreur de fuite de mémoire...

[Caine]

Si tu es sous Windows, il y a une astuce simple:
Tu te fais une application de test qui créait un grand nombre de tes objets.

Tu utilises le gestionnaire de tâche, tu note avant de lancer l'application combien il y a de RAM libre.

Tu lances ton application, et uniquement elle! Toujours à partir du gestionnaire, tu note la RAM libre et utilisée.

Tu ferme correctement ton application et tu notes la RAM libre, tu dois avoir moins de 1% de différence.

Tu n'as pas de risque de fuite mémoire si tu n'utilises pas d'allocation dynamique (new ou malloc).

[benj63]

Merci encore pour cette astuce.
Je pense que je vais essayer de faire comme ça pour vérifier les fuites mémoires.

(il me reste malgré tout un souci à cause des threads, il y a 2 fonctions qui ouvrent de gros fichier dans des TStringList, et qui sont lancées par 2 threads en même temps... et ça m'envoie une alerte "pas assez de mémoire". Je vais essayer de corriger ça à présent )

[Caine]

Est-il nécessaire d'avoir deux exemplaires des fichiers en mémoire?

Car il est possible de partager de la mémoire entre Thread.

L'API windows est bien pourvu pour ça:
Partage entre processus=> CreateFileMapping et fonctions associées.

Partage entre Thread => N'importe quelle variable globale peut être partagée entre Thread, MAIS PAS ENTRE PROCESSUS. Il faut cependant en sécuriser l'accès en Ecriture/Lecture par mutex, section critique et mon préféré Lecteur Rédacteur (le nom du composant est à rallonge, je ne m'en suviens plus).

Partage entre thread mais local à chacun des thread: TLSData et fonctions associées.

Regarde l'aide pour les détails.

[benj63]

Malheureusement il est nécessaire d'avoir les 2 fichiers en mémoire. Et en +, j'utilise d'autres classes qui traitent les fichiers donc il serait trop complexe de gérer en mémoire les accès et leur partage (vu le temps qu'il m'est alloué pour faire cela).

Les erreurs mémoire apparaissent lorsque j'utilise CodeGuard : même en faisant des try catch sur les points qui posent problème, la fonction s'arrête et ne va pas jusqu'au bout. En désactivant codeguard et en mettant l'application en version finale, je n'ai aucun message de manque de mémoire (ni même un access violation), et les 2 fonctions appelées par les 2 threads vont jusqu'au bout.

Je te remercie néanmoins pour ces précisions !

[Neilos]

Pour le fuites mémoire sous C++ Builder il suffit d'activer CodeGuard dans les options du projet....il les trouveras comme un grand si elles se produisent à l'exécution !

[benj63]

ben justement non, pour les threads j'ai constaté des endroits où il ne trouvait pas de fuites mémoires alors qu'il y en avait...

mais il est vrai que généralement j'utilise CodeGuard, c'est bien pratique !!