tester un mutex

Version imprimable

tester un mutex

bonjour,
je cherche a tester si un mutex fonctionnent correctement, voici la fonction qui l'utilise

Code:

1
2
3
4
5
6
EUpdateResult RulesDataMapper::update(const bool statement){
	lock.lock();
...
    lock.unlock();
    return result;
}

cette fonction se situe dans la classe RulesDataMapper que je souhaite tester
j'ai alors un autre classe RulesDataMapperTest pour cela
pour l'instant voici la code que j'ai mais qui ne marche pas ça me génère un erreur

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
TEST_F(RulesDataMapperTest, testMultiThreadingResistance){
        std::thread thread1(r1->update(true));
...
ERREUR 
In file included from /usr/include/c++/5/mutex:42:0,
                 from /home/charles/Desktop/Westguard-SSM/src/test/../Controller/../DataMapper/RulesDataMapper.h:25,
                 from /home/charles/Desktop/Westguard-SSM/src/test/../Controller/EvaluateController.h:16,
                 from /home/charles/Desktop/Westguard-SSM/src/test/EvaluateControllerTest.h:9,
                 from /home/charles/Desktop/Westguard-SSM/src/test/AllTest.cpp:10:
/usr/include/c++/5/functional: In instantiation of ‘struct std::_Bind_simple<EUpdateResult()>’:
/usr/include/c++/5/thread:137:59:   required from ‘std::thread::thread(_Callable&&, _Args&& ...) [with _Callable = EUpdateResult; _Args = {}]’
/home/charles/Desktop/Westguard-SSM/src/test/RulesDataMapperTest.h:598:75:   required from here
/usr/include/c++/5/functional:1505:61: error: no type named ‘type’ in ‘class std::result_of<EUpdateResult()>’
       typedef typename result_of<_Callable(_Args...)>::type result_type;
                                                             ^
/usr/include/c++/5/functional:1526:9: error: no type named ‘type’ in ‘class std::result_of<EUpdateResult()>’
         _M_invoke(_Index_tuple<_Indices...>)

ma queston est donc la suivante es ce que pour tester un mutex on dois passer pas différent thread que l'on dois exécuter en même temps ? si oui comment créer un thread ?

25/04/2018, 10h33
Bousk

Salut,

Un mutex sert à bloquer un thread/une opération.
Si tu n'as qu'un seul thread, tu vas vouloir bloquer ton unique thread pendant que... rien du tout, tu n'as aucun autre thread. Donc oui faut au moins 2 thread pour qu'un mutex ait quelconque utilité :calim2:
Si tu veux tester qu'un mutex est lockable, il y a try_lock.
Si tu veux tester qu'un mutex "fonctionne".. euh compte juste sur l'implémentation pour être correcte. :roll:

Vues tes erreurs, ton code ne semble pas compiler.
25/04/2018, 10h46
quinroux

merci pour la reponse,

Citation:

Si tu n'as qu'un seul thread, tu vas vouloir bloquer ton unique thread pendant que... rien du tout, tu n'as aucun autre thread. Donc oui faut au moins 2 thread pour qu'un mutex ait quelconque utilité

je n'ai mit qu'un seul thread dans mon exemple c'est vrais mais de toute façon il me généré une erreur lors de la compilation donc un ou deux pas de différence, mais dans mon code final bien sur qu'il y a deux thread, du coup comment déclare t'on un thread j'ai essayer plusieurs méthode mais aucune n'a fonctionner
25/04/2018, 11h56
dalfab

Bonjour,

Non, il n'y pas un mais deux threads dans ton exemple, car un thread est créé (par le thread principal). On peut donc "jouer" avec les mutex.

Pour créer un thread, il faut lui passer une fonction à exécuter. Il ne faut pas lui passer le résultat d'un appel de fonction.
On peut remplacer std::thread thread1(r1->update(true)); par

Code:

std::thread thread1( [&]() { return r1->update(true); } ); // dérouler la fonction comme étant un thread
25/04/2018, 12h16
Bktero
Code:

1 2 3 4 5 6 EUpdateResult RulesDataMapper::update(const bool statement){ lock.lock(); ... lock.unlock(); return result; }
Bonjour,

Quand tu auras résolu tes erreurs de compilation, tu pourras regarder lock_guard qui devrait te permettre de simplifier ta gestion des lock/unlock de ton mutex : http://en.cppreference.com/w/cpp/thread/lock_guard
25/04/2018, 14h40
quinroux

merci beaucoup de votre aide et conseille j'ai réussis a faire marcher mon teste comme je le voulais
25/04/2018, 20h16
koala01

Salut,

Ceci étant dit: le simple fait de vouloir utiliser des mutexes peut souvent être considéré comme le symptôme d'un mal beaucoup plus grave: le fait que, à un moment ou à un autre, on voudra empêcher un thread particulier d'accéder à certaines données dont il semble avoir besoin.

L' *** idéal *** étant de faire en sorte que chaque thread puisse manipuler "à son aise" ses "propres données" sans avoir à s'inquiéter du fait qu'il puisse y avoir "un autre thread" qui tente d'y accéder.

Et pour arriver à ce résultat, l'idéal est -- bien sur -- de faire en sorte que chaque thread se contente de manipuler "ses données à lui".

Nous sommes tous, bien sur, tout à fait conscients du fait que "c'est parfois vachement dur", et qu'il arrive même que "ce soit à peu près impossible".

Mais il faut comprendre que l'utilisation de threads n'aura réellement un intérêt que si chaque thread peut travailler "à son aise" sans avoir besoin d'attendre... qu'un autre thread ait libérer "une donnée" pour pouvoir y accéder.

Pire encore : dans certains cas particuliers, on peut se trouver confrontés à deux threads dont un "verrouille l'accès" à une donnée alors que l'autre a déjà eu "l'autorisation de principe" d'y accéder. Et cela occasionne un blocage mutuel des threads appelé "death lock".

Alors bon... je ne met nullement en doute ton besoin d'avoir recours à des threads. Je peux comprendre que tu aies peut-être besoin de mutexes. Mais si j'ai un conseil d'ami à te donner, c'est bien d'essayer... de tout faire pour t'en passer :P