[synchronisation] worker threads

Hello,

j aimerais savoir quel mecanisme choisir pour faire de la synronisation multithreading.


En gros j ai besoin d'avoir un accès exclusif a une ressource utilisée pas deux worker threads differents.

j ai deja fais un essais avec une section critique et un single lock et un autre essais avec un mutex et un single lock; mais je dois pas avoir tout compris.

Dites moi juste les types et nombre d objets a utiliser, je me debrouillerai pour implementer.

ex : 1 single lock different par thread + 1 section critique commune.


j aimerais vraiment la reponse de qqn qui a deja realisé correctement ce genre de synchro avec les MFC;)

Les sections critiques et les mutex fonctionnent de la même façon. La seule différence entre les 2 est qu'un mutex est également visible d'un autre programme (utile si plusieurs soft accèdent à la même ressource).

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

#define TPSMAX 10000 CCriticalSection sc;   // dans le thread 1 : sc.Lock(TPSMAX); // accès aux ressources partagées sc.Unlock()   // dans le thread 2 : sc.Lock(TPSMAX); // accès aux ressources partagées sc.Unlock()

---

De plus, sous MFC, on peut utiliser la classe CSingleLock qui appelle automatiquement Unlock() dans son destructeur.

Citation:

---

Envoyé par SERTNM

Les sections critiques et les mutex fonctionnent de la même façon. La seule différence entre les 2 est qu'un mutex est également visible d'un autre programme (utile si plusieurs soft accèdent à la même ressource).

---

Je ne suis pas certain mais je pensais qu'il y a avait une autre différence. Notamment que lorsque que l'on se trouve dans une section critique, le processeur n'est plus alloué pour une autre tâche (le multi-tache est temporairement stoppé, d'où l'importance de faire des opérations courtes dans les sections critiques) alors qu'avec l'utilisation de mutex, on conserve le multi-tache, à moins évidemment que toutes les autres tâches soient en attente de la même ressource. ;)

Dites moi si je me trompe?

Nicolas

Citation:

---

Envoyé par ZaaN

En gros j ai besoin d'avoir un accès exclusif a une ressource utilisée pas deux worker threads differents.

---

Une autre solution peut être d'implémenter un sémaphore à un jeton pour réaliser une mutex.

oui tu te trompes,
avec un section critique un thread en train de protéger une portion de code pourra être préempté par le système pour planifié un ou plusieurs threads.
les threads suspendus par EntercriticalSection et sur la même section critique ne seront pas planifiés.
donc un thread préempté pendant un section critique est assuré que le système ne donnera pas la main a un autre thread voulant utiliser la même section critique.
la différence avec le mutex c'est que celui ci repose sur un objet global du système alors que la section critique sur un objet global du processus.
le mutex permet alors effectivement l'utilisation entre plusieurs processus.
:D

Ok, c'est clair!

J'ai du confondre...Pour info, existe-il sous Windows, une fonction qui permette justement de suspendre toute préemption pour l'éxécution unique d'un code dans une section?

Sans forcément avoir besoin d'utiliser un thread avec la priorité THREAD_PRIORITY_TIME_CRITICAL, chose que je n'ai jamais essayé mais, à ce que j'ai compris, doit nécessairement se terminer pour redonner la main à d'autres threads.

Sous VxWOrks( qui est par contre un RTOS), j'ai le souvenir d'avoir utilisé des fonctions permettant justement d'interdire la préemption pour éxécuter un bout de code spécifique.

Rien ne peut empêcher la préemption sous Windows, sauf peut-être mettre un thread en THREAD_PRIORITY_TIME_CRITICAL dans un process en REALTIM_PRIORITY_CLASS.
Cela donnera la priorité absolument maximale au thread, mais s'il y a un autre thread qui s'exécute avec la même priorité, il y aura toujours partage de temps...