Discussion :

[gregfly26]

Bonjour

je souhaite utiliser des mutex pour gérer le lancement de 4 threads mais je ne sais pas comment faire. Je sais créer le mutex mais je ne sais pas l'utiliser.

Si vous aviez un exemple ce serait cool !

Car on trouve pas grand chose sur google sur les mutex en c++.

[10_GOTO_10]

Code :

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

1
2
3
4
hMutex = CreateMutex(NULL, FALSE, "TOTO FAIT DU SKI");
if (GetLastError() == ERROR_ALREADY_EXISTS) {
  // Alors le mutex existait déjà
}

[gregfly26]

ce code crée le mutex non ?

mais comment l'utiliser dans mon programme ?

[Neo41]

Bonjour,

Pour l'utiliser il faudra faire appel à une des fonctions wait, comme WaitForSingleObject avec comme paramètres le handle du mutex crée.

Pour libérer le mutex il faut appeler ReleaseMutex.
Regardes dans l'aide c'est bien expliqué.

Bon courage

[DjmSoftware]

bonjour,
pour l'utilisation en multithread l'utilisation de semaphore est préférable aux Mutex
cordialement

[gregfly26]

j'ai vu cette fonction me c tt en anglais je compren rien !

je doi la place ou cette fonction ? dans mon thread ou ds mon cpp la ou je lance le thread ?

Vous connaissez pas un tuto pr utilise les mutex ?

[Troll]

Ne t'emballe pas !

Gérer le lancement de thread avec des mutex n'a pas vraiment de sens.
On les utilise plus généralement pour contrôler l'exécution
et plus précisément l'accès au ressources partagés.
Typiquement on va utiliser un mutex pour éviter deux écritures simultanées
ou une écriture avec une lecture, etc.

Donc, pourquoi veux-tu utiliser des mutex?

Sinon, personnellement j'utilise plutôt des section critiques

Code :

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

1
2
3
4
 
CRITICAL_SECTION Sync;
EnterCriticalSection(&Sync);
LeaveCriticalSection(&Sync);

Avec un mécanisme de "garde" pour éviter de se casser la tête avec la gestion d'erreur/exception.

[gregfly26]

Je dois utiliser les mutex dans mon projet bts car c'est inscri ds le cahier des charges.

Mon projet es de gere un traitemen de surface !

Mon prog contient 4 thread : transfert , anodisation , traitement1 et traitement2.

Ces threads ne doiven en aucun cas etre lance en mm tps donc le mutex devra interdir l'execution des autre thread si un thread es lance mais devra fer une file d'attente en memorizan les demande des threads pour les lancer lorsque le premier aura fini.

J'esper que vous avez compri ce que je doi fer! si c pa kler demande moi !

merci pour votre aide

[Troll]

C'est aussi dans le cahier des charges d'avoir 4 threads ??

Avoir des threads et leur interdire de s'exécuter "simultanément"; ça n'a pas plus de sens.
Le plus judicieux est d'avoir un seul thread qui effectue tous les types de traitements,
les uns à la suite des autres.

Qu'en penses-tu ?

[gregfly26]

ben en fait chaque operation doi etre disctincte et ne doi pa bloke l'IHM.

les 4 operations doivent pouvoir se fer ds plusieurs ordre differents donc je suis oblige de les separé. Mais il utilise tous un bras robot et il ne pa possible ke le bras soi utilise par plusieur processus en mm tps !

voila pk je doi utilise un mutex et des thread !

A - ke vs ayez une autre solution !

[Troll]

Bon, ça commence à devenir clair.

Le nombre de thread que tu vas utiliser dépend de tes type de traitement.
Si l'essentiel des traitement utilise le bras Robot, un seul thread suffit (en plus du Main-thread qui reste dédié à l'IHM).
S'il y a d'autres actions importantes (en terme de temps d'éxectution) et indépendantes
tu auras intérêt à définir autant de thread que de type de traitment.

Au sujet de l'accès au bras Robot.
Le bras Robot est la ressource partagée, c'est donc l'accès à cette ressource que tu dois protéger.
Au niveau conceptuel tu devrais avoir une classe singleton pour le bras.
La classe bras doit avoir des méthodes pour chaque actions différentes.
Et chaque action doit être protéger par un mutex.

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
 
class Robot
{
public:
  ~Robot();
   static Robot* GetInstance();
 
  void ActionTransfert();
  void ActionAnodisation();
  void ActionTraitement1();  
   ....
private:
  Robot(){}; // le constructeur du singleton doit être privé 
 
  static Robot* _Instance; // Le Singleton
  CRITICAL_SECTION _criticalSection;
  ...
}

Implémentation :

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
 
Robot::_Instance(0); // Initialisation du membre static
 
Robot* Robot::GetInstance()
{
  if(_Instance==0)
     _Instance = new Robot();
 
   return _Instance;
}
 
void Robot::ActionTransfert()
{
  EnterCriticalSection(&_criticalSection);
   // Il ne peut y avoir qu'un seul thread en section critique
 
   // Ici tu codes les opérations du bras pour le transfert
   ....
  LeaveCriticalSection(&_criticalSection);
}

Appels au Robot

Code :

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

1
2
 
  Robot::GetInstance()->ActionTransfert();

Si toutes les action sont construites sur le modèl d'ActionTransfert, tu auras la garantie qu'elles s'exécuteront de manière séquentielle.
(peut qu'il y ait 1, 2 ou 10 threads)
Le premier thread qui entre en section critique bloque les autres qui essaye de rentrer aussi, jusqu'a ce qu'il en sorte.
Après le premier bloqué et le premier libéré.

Attention un même thread ne peut entrer deux fois dans la même section critique
sans resortire une première fois, sinon il se bloque lui même.
S'il y a une exception la section critique n'est pas automatiquement liberée


J'espère que cela va t'aider.
Si tu es intérressé je peux t'expliquer un syteme de garde qui simplifie la gestion d'erreur/exception.[/code]