Discussion :

[arthurG]

Bonjour,

J'ai un problème avec les threads boost :

J'ai créé une classe qui contient un thread. J'utilise un pointeur :

Code :

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

1
2
3
 
typedef boost::shared_ptr <boost::thread> thread_ptr;
thread_ptr thread;

Dans le constructeur de la classe je lance une fonction qui fait :

Code :

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

1
2
3
 
thread = thread_ptr (new boost::thread(&MaClasse::threadFct, this));
activeThread = true;

et la fonction threadée :

Code :

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

1
2
3
4
5
6
 
void MaClasse::threadFct () {
while (activeThread) {
...
}
}

Au destructeur de la classe je fais :

Code :

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

1
2
3
4
5
6
 
mutex.lock ();
activeThread = false;
mutex.unlock ();
 
thread->join();

Et c'est là que ça bloque. D'après le log le thread sort bien de la fonction MaClasse::threadFct, alors je ne comprend pas pourquoi le join puisse bloquer comme je ne demande plus rien au thread.
Si quelqu'un avait une idée

[Trademark]

Salut !

La fonction join attend la fin de l'exécution d'un thread. Donc il ne peut pas s'attendre.

Comme noté dans les préconditions :

Preconditions:

this->get_id()!=boost::this_thread::get_id()

Le cas échéant, le thread va s'attendre tout seul et il a pas fini d'attendre. Il faut que ça soit le thread appelant qui utilise cette fonction (et plus spécifiquement lorsque le flot d'exécution du thread appelant ne peut continuer sans la terminaison du thread appelé).

Ensuite, mais vu que tu ne donnes pas le reste de ton code c'est difficile de juger, il semblerait que tu utilises une boucle active, qui n'est généralement pas une bonne idée.

[arthurG]

Salut, merci pour la réponse !

En fait ce n'est pas le thread qui s'attend mais la classe qui l'a lancé

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
 
MaClasse {
...
typedef boost::shared_ptr <boost::thread> thread_ptr;
thread_ptr thread;
};
 
MaClasse::MaClasse () {
thread = thread_ptr (new boost::thread(&MaClasse::threadFct, this));
activeThread = true;
}
 
MaClasse::~MaClasse () {
mutex.lock ();
activeThread = false;
mutex.unlock ();
 
thread->join();
}
 
void MaClasse::threadFct () {
while (activeThread) {
...
}
}

Ce qui est mauvais dans la boucle, c'est l'utilisation de la variable d'état ?
Comment lancer un thread durant l'existence d'une classe avec un autre moyen ?

[screetch]

et si tu fais pause dans un debugger et que tu regardes ce que fait le thread en question?

[Trademark]

Désolé j'avais mal regardé, je ne sais pas pourquoi le join attend infiniment.

Pour éviter d'avoir une boucle active (while(true)), ça dépend un peu du traitement effectué dans celle-ci. Mais tu devras probablement utiliser les primitives wait et notify.

Ensuite à quoi est initialisé activeThread avant la création du thread ? Tu ne sais pas... C'est donc la roulette et si il est initialisé à faux, il se peut que le thread fraichement créé ne rentre même pas dans la boucle. Attention donc aux problèmes de synchronisation pouvant apparaitre...

[Ekleog]

Réponse faite à l'arrache : Où est-ce que tu lances ton thread ? Est-ce que ça ne pose pas de problème d'appeler join() sur un thread non lancé ?

Oups, après vérification boost lance automatiquement le thread. Désolé.