[boost::thread] [mutex] Threader une méthode
Bonjour.
J'ai besoin d'utiliser les thread pour un projet, j'utilise donc boost::thread.
Mon but est de threader une fonction membre d'une classe qui est non copiable (boost::noncopyable), je ne sait pas si la technique que j'ai mis en place est la bonne, mais en utilisant un foncteur copiable a l'intérieur de ma classe, j'ai pu réaliser mon thread.
Mais le problème est que je vais devoir bloquer des threads lors de l'utilisation de données communes (avec un mutex ?), mais je n'ai pas très bien compris comment fonctionnait ces mutex (j'ai lu la doc et le tuto du site, mais je suis pas sur d'avoir compris) :
-> Je doit créer autant de mutex que de variables à protéger ?
-> Il faut créer des mutex pour toutes les variables partagées, ou seulement pour celles dont l'état est modifié par la fonction ?
-> Si j'ai bien compris je doit créer le mutex (boost::mutex mutex;) le vérouiller dans un bloc ({boost::mutex::scoped_lock lock(mutex); /*traitement de la variable*/}) et il sera automatiquement dévérouiller a la sortie du bloc (RAII) ?
-> Dans mon code (ci dessous), je doit protéger tous les attributs utilisé à la fois par les fonctions membres et par le thread (directement ou indirectement) ?
-> Je ne vois pas trop comment gérer m_continuer, comme les mutex sont dévérouillés automatiquement a la sortie d'un bloc (RAII) comment faire pour garantir que stop() n'accédera pas a m_continuer en même temps que le while ?
-> (question qui n'a rien a voir avec les threads) c'est normal que j'ai un warning quand je rajoute boost::noncopyable à B (warning: direct base 'boost::noncopyable_::noncopyable' inaccessible in 'NAMESPACE_PERSO::A<T>::B' due to ambiguity)
Code:
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
#include <iostream>
#include <boost/thread.hpp>
#include <cstdlib>
#include <boost/utility.hpp>
template <class T>
class A : boost::noncopyable
{
private:
class B : public T
{
public:
void update(/*différent paramètres*/)
{
//effectue un traitement sur les attribut de B en fonction des paramètres
T::update(/*différent paramètres dépendant des attributs du B*/);
}
private:
//différent attributs
};
class ThreadFunc //class servant d'intermédiaire pour threader A() avec A non copiable
{
public :
ThreadFunc(A* a) : m_a(a) {}
void operator()()
{
(*m_a)();
}
private :
A* m_a;
};
public:
A() : m_thread(NULL) {}
~A()
{
//+ autre opération de libération de certains attribut alloué dynamiquement
delete m_thread;
}
void operator()()
{
while(m_continuer)
{
//calcul du paramètre a passer a update, dépend d'un attribut de A
update(/*un paramètre*/);
}
}
T* add_b()
{
//ajoute un elt au conteneur de B, et retourne un T* sur cet elt
}
//+ une autre méthode ajoute un elt a l'autre conteneur
void run () //lancer le thread
{
m_continuer = true;
m_thread = new boost::thread(ThreadFunc(this));
}
void stop () //arretter le thread
{
m_continuer = false;
m_thread->join();
}
private:
void update (/*un paramètre*/)
{
//effectue des calcul dépendant des conteneurs, et appèle update pour tout les B du conteneur
}
bool m_continuer;
boost::thread* m_thread;
//+ un conteneur de B
//+ un autre conteneur
};
int main( )
{
A<T> a;
T* t = a.add_b();
a.run();
//utilisation des diiférente méthode de T sur t
a.stop();
return EXIT_SUCCESS;
} |
Merci d'avance.
