Boost et les Threads

Bonjour tout le monde,
j'aimerai utiliser les threads de boost.
J'ai trouvé la doc sur le site de boost pour la creation des threads et leur utilisation.
Mais je ne parviens pas a trouver un exemple d'utilisation de section critique. L'equivalent de pthread_mutex_lock et pthread_mutex_unlock. Si quelqu'un pouvait me dire si un tel tutorial/exemple de code existe et où le trouver cela m'aiderai grandement.

Voila un bout de code pour illustrer ce que je dis. En fait, j'aimerai trouvé l'équivalent des fonction de la lib pthread vers la lib BOOST.

D'avance merci

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

#include <iostream> #include <windows.h>   #include <boost/thread/thread.hpp>   using namespace std;     //EQUIVALENT BOOST --> static pthread_mutex_t mutex;   int nb=0;   void fct3() { while (nb<=20) {   //EQUIVALENT BOOST --> pthread_mutex_lock (&mutex);   int mynb=nb; Sleep(1000); cout << "Thread 1, nb : " << mynb << " = " << nb << endl; nb++;   //EQUIVALENT BOOST --> pthread_mutex_unlock (&mutex);   }   }       void fct4() { while (nb<=20) {   //EQUIVALENT BOOST --> pthread_mutex_lock (&mutex);     int mynb=nb; Sleep(1000); cout << "Thread 2, nb : " << mynb << " = " << nb << endl; nb++; //EQUIVALENT BOOST --> pthread_mutex_unlock (&mutex);   } }     int main() {     boost::thread thrd1(&fct3); boost::thread thrd2(&fct4); thrd1.join(); thrd2.join();     cout << "Fin" << endl;   return 0; }

---

Ce programme ne fait pas grand chose, mais me permet de tester la syntaxe de l'utilisation des threads.

C'est pas ça que tu cherches ? http://boost.org/doc/html/mutex.html

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

class counter { public: // Doesn't need synchronization since there can be no references to *this // until after it's constructed! explicit counter(int initial_value) : m_value(initial_value) { } // We only need to synchronize other for the same reason we don't have to // synchronize on construction! counter(const counter& other) { boost::mutex::scoped_lock scoped_lock(other.m_mutex); m_value = other.m_value; } // For assignment we need to synchronize both objects! const counter& operator=(const counter& other) { if (this == &other) return *this; boost::mutex::scoped_lock lock1(&m_mutex < &other.m_mutex ? m_mutex : other.m_mutex); boost::mutex::scoped_lock lock2(&m_mutex > &other.m_mutex ? m_mutex : other.m_mutex); m_value = other.m_value; return *this; } int value() const { boost::mutex::scoped_lock scoped_lock(m_mutex); return m_value; } int increment() { boost::mutex::scoped_lock scoped_lock(m_mutex); return ++m_value; } private: mutable boost::mutex m_mutex; int m_value; };

---

J'ai bien deja vu tout ca, mais je ne comprend pas trop.:oops:

La doc sur la création des threads contient un exemple : http://boost.org/doc/html/threads/ra...opyable.joined
Ce qui (pour moi) est beaucoup plus simple a comprendre.
Mais je n'ai rien trouvé sur la syntaxe pour l'utilisation des mutex.

Il y a un mutex par instance de classe.
Lorsqu'on veut le locker, on le donne en argument à un
boost::mutex::scoped_lock
qui va le locker et le libérer à la sortie du bloc, à l'extérieur du "scope".

En fait, ce que je chercher surtout c'est l'équivalence de la librairie pthread en BOOST, en ce qui concerne :
pthread_mutex_lock (&mutex) et
pthread_mutex_unlock (&mutex)
Merci

Désolé j'avais pas encore vu ton dernier message quand j'ai posté ca !:roll:

Pourrais-tu stp, me donner un exemple simple de code pour m'illustrer ca, si tu en as un sous la main. Parceque je comprend pas trop.:hola:

Je l'ai donné plus haut.
Le lock correspond à la création de l'objet scoped_lock, le unlock correspond à sa destruction, à la sortie du bloc.