Discussion :

[marie6631]

Bonjour,

maintenant que j'ai compris le fonctionnement d'un thread, je voudrais faire récupérer les variables de mon projet dans la fonction commandée par le thread. Cette dernière est déclarée en static donc cela pose un problème d'échange de variables.
Je sais qu'on peut passer des structures mais cela n'arrange pas mon problème.

En gros, j'ai une fonction qui me permet d'afficher le profil de mon image live. Dans cette fonction je remplis mon tableau avec la valeur des pixels.
Maintenant je voudrais en cliquant sur un bouton, traiter ce profil en récupérant mon tableau et sortir mon tableau traité et l'afficher....Le thread s'occuperait de ce traitement.

est ce possible ?

merci

[3DArchi]

Oui c'est possible.
Tu devras passer quelque chose qui te donne accès à tes variables et mettre en place un système de contrôle d'accès concurrent (un mutex?).

[marie6631]

oui pour le mutex, je vois.

est ce que syntaxiquement, il y a une différence entre le code d'un thread de service et un thread interface ? car dans mon cas l'affichage des valeurs traitées doit passer par un thread interface.

merci

[3DArchi]

oui pour le mutex, je vois.

est ce que syntaxiquement, il y a une différence entre le code d'un thread de service et un thread interface ? car dans mon cas l'affichage des valeurs traitées doit passer par un thread interface.

merci

De mémoire, il y a des choses qui se comportent bizarrement quand tu as plusieurs thread qui possèdent des fenêtres et autre boîte de dialogue. Et franchement, je ne me souvient pas avoir été confronté au réel besoin d'avoir plusieurs thread d'interface. En général, un seul pour gérer les fenêtres et les autres pour travailler.

[marie6631]

bonjour,

je suis en train d'ajouter des mutex dans mon code pour gérer les variables.

Est ce que lorsque je fait un CreateMutex(...) dans le "main" et WaitForSingleObject(...) et ReleaseMutex(...) dans la fonction thread, cela suffit .

ou faut il rajouter les fonctions Lock et Unlock de la classe CMultiLock pour activer réellement les mutex ?

merci d'avance

[3DArchi]

Bonjour,
CMutex t'évite de passer par l'api CreateMutex/ReleaseMutex.
L'idée des CSingleLock/CMultiLock est d'encapsuler les appels à WaitForSingleObject.
L'utilisation suit ce genre de trame :

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
 
class ObjetPartage
{
public:
   int get_variable()const;
   void set_variable(int);
private:
    mutable CMutex m_mutex;
    int variable;
};
int ObjetPartage::get_variable() const
{
    CSingleLock lock(&m_mutex,TRUE);
    // ok
    return variable;
}
void ObjetPartage::set_variable(int new_)
{
    CSingleLock lock(&m_mutex,TRUE);
    // ok
    variable=new_;
}

[marie6631]

merci.

est-il possible qu'une fonction de thread appelle une dll ?

merci d'avance

bon week end

[3DArchi]

Salut,
De mémoire, il ne me vient pas de problème particulier sur l'appel d'une DLL dans un thread distinct. Les problèmes de synchronisation et d'accès concurrents seront les mêmes qu'avec un appel dans le même module.

[marie6631]

bonjour,

je suis toujours en train de travailler avec mes thread. je récapitule mon nouveau problème de thread et variable.

je travaille sous visual c++ 6 en mode boite de dialogue. lorsque j'appuie sur un bouton de traitement, je lance une fonction thread de traitement de mon profil (appel une dll de traitement) et je l'affiche. je voudrais maintenant accéder à la variable traitrée depuis un autre thread tout en laissant tourner le thread de traitement, pour appliquer un autre traitement à cette variable. parce qu'en accédant directement à ma variable dans ma fonction thread traitement, cela ne fonctionne pas.

Est ce possible ? Est ce du multithread ?

je ne sais pas si c'est très clair.
merci d'avance

[3DArchi]

Bonjour,
Oui, c'est clair... modulo 1 question :
Si V1 est ta variable partagée utilisée par les threads T1 et T2
Est-ce que toute modification de V1 dans T1 (resp. T2) doit être vue dans T2 (resp. T1) ?

Si la réponse est non : alors cloisonne et partage la variable par copie.
Si la réponse est oui : alors encapsule ta variable dans une classe comprenant une section critique ou un mutex permettant le partage.

[marie6631]

si V1 est modifiée par T1 alors elle doit être modifiée dans T2. Mais T2 ne doit pas modifier la valeur de V1 pour T1. Il n'y a qu'un sens....

Je vais voir ce que je peux faire

Merci

[3DArchi]

V1 est un type simple ? En fait, acceptant facilement la copie par construction ?

[marie6631]

je ne comprends pas cette dernière réponse ...

[3DArchi]

Salut,
L'idée est de retourner dans T2 la variable par valeur. Ainsi, la classe que je te proposais peut très bien convenir :

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
 
template<class TVariable>
class ObjetPartage
{
   typedef ObjetPartage<TVariable> this_type;
public:
   ObjetPartage(TVariable &vinit_)
      :variable(vinit_)
   {
   }
   TVariable get_variable()const
   {
      CSingleLock lock(&m_mutex,TRUE);
      TVariable retour(variable);
      return retour;
   }
   void set_variable(TVariable new_val_)
   {
      CSingleLock lock(&m_mutex,TRUE);
      // ok
      variable=new_val_;
   }
private:
   // non copiable :
   ObjetPartage(this_type const&);// ne pas definir
   this_type& operator=(this_type const&);// ne pas definir
private:
    mutable CMutex m_mutex;
    TVariable &variable;
};

Ensuite tu créés une instance de ObjetPartage avec ta variable que tu partages entre tes threads.