boost::thread sur linux (je n'y arrive pas) :(

bonjour, je souhaite utiliser boost::thread et je n'arrive pas à la faire fonctionner :-(

file main.cpp
-----------------------------
1 #include <iostream>
2 #include <boost/thread/thread.hpp>
3 #include <boost/thread/mutex.hpp>
4 #include <boost/bind.hpp>
5
6 boost::mutex io_mutex;
7
8 void count(int id)
9 {
10 for (int i = 0; i < 110; ++i)
11 {
12 boost::mutex::scoped_lock lock(io_mutex);
13 std::cout << id << ": " << i << std::endl;
14 }
15 }
16 int main(int argc, char* argv[])
17 {
18 boost::thread thrd1(boost::bind(&count, 1));
19 boost::thread thrd2(boost::bind(&count, 2));
20 thrd1.join();
21 thrd2.join();
22 return 0;
23 }
-----------------------------
source de l'exemple : http://aszt.inf.elte.hu/~gsd/klagenf...l/ch03s06.html
-----------------------------
g++ -lboost_thread -lpthread main.cpp -o main && ./main
1: 0
1: 1
1: 2
1: 3
1: 4
1: 5
1: 6
1: 7
1: 8
1: 9
2: 0
2: 1
2: 2
2: 3
2: 4
2: 5
2: 6
2: 7
2: 8
2: 9
-----------------------------
visiblement les fonctions count(1) et count(2) s'exécutent l'une après l'autre :-(

par avance merci et bon courage.

PS : avec l'autre exemple j'obtiens des résultats semblables

Salut,

J'imagine que tu as tronqué la sortie puisque les boucles vont jusqu'à 110 ?
C'est quoi le problème exactement ? Tu voudrais qu'il se produise quoi à la place ?

MAT.

tu as raison, le code source que j'ai mis ne correspond pas à ce qui à été compilé et exécuté ... (résidu de quelques tests)

10 for (int i = 0; i < 110; ++i)
10 for (int i = 0; i < 10; ++i)

Pour répondre à ta question, dans le résultat que j'obtiens, j'ai l'impression que la fonction count(2) ne commence à s'exécuter que lorsque la fonction count(1) à terminé ...

je m'attendais à un résultat ressemblant à :
-------------------------------------------------------------
1: 0
1: 1
1: 2
2: 0
1: 3
2: 1
1: 4
2: 2
2: 3
1: 5
2: 4
1: 6
2: 5
2: 6
1: 7
2: 7
1: 8
2: 8
1: 9
2: 9
---------------

merci pour ta première réponse ...

D'accord mais du coup le résultat n'est pas forcément anormal, avec une boucle aussi petite ça ne me choque pas plus que ça qu'il n'y ait pas le temps pour un changement de contexte pour passer dans thread à l'autre.
C'est un peu le principe des threads (préemptifs) que ça soit le système qui se débrouille pour optimiser la répartition.

MAT.

-----------------------------------
#include <iostream>
#include <boost/thread/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>

boost::mutex io_mutex;

void count(int id)
{
for (int i = 0; i < 110; ++i)
{
boost::mutex::scoped_lock lock(io_mutex);
std::cout << id << ": " << i << std::endl;
for(int x=0;x<100000000;++x) i=i;
}
}
int main(int argc, char* argv[])
{
boost::thread thrd1(boost::bind(&count, 1));
boost::thread thrd2(boost::bind(&count, 2));
thrd1.join();
thrd2.join();
return 0;
}
------------------
g++ -lboost_thread -lpthread main.cpp -o main && ./main
1: 0
2: 0
2: 1
2: 2
2: 3
1: 1
1: 2
1: 3
1: 4
1: 5
2: 4
2: 5
2: 6
2: 7
2: 8
2: 9
1: 6
1: 7
1: 8
1: 9
-----------------
merci beacoup

Si tu n'as qu'un cœur, que ton time slice est suffisamment long et ton code suffisament court pour que le thread puisse être éxecuté sans être préempté, forcément ça parait séquentiel...