Boost et les Threads

**TuRn3r** · 10/05/2006, 10h05

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 :

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
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.

**Matthieu Brucher** · 10/05/2006, 10h15

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

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
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;
};

**TuRn3r** · 10/05/2006, 10h20

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

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.

**Matthieu Brucher** · 10/05/2006, 10h26

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".

**TuRn3r** · 10/05/2006, 10h28

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 !