Geek Answers Handbook

Boost :: thread execution order

I have a problem with the execution order of threads created sequentially. here is the code.

#include <iostream>
#include <Windows.h>
#include <boost/thread.hpp>

using namespace std;

boost::mutex mutexA;
boost::mutex mutexB;
boost::mutex mutexC;
boost::mutex mutexD;


void SomeWork(char letter, int index)
{
    boost::mutex::scoped_lock lock;
    switch(letter)
    {
    case 'A' : lock = boost::mutex::scoped_lock(mutexA); break;
    case 'B' : lock = boost::mutex::scoped_lock(mutexB); break;
    case 'C' : lock = boost::mutex::scoped_lock(mutexC); break;
    case 'D' : lock = boost::mutex::scoped_lock(mutexD); break;
    }

    cout << letter <<index << " started" << endl;
    Sleep(800);
    cout << letter<<index << " finished" << endl; 
}

int main(int argc , char * argv[])
{
    for(int i = 0; i < 16; i++)
    {
        char x = rand() % 4 + 65;
        boost::thread tha = boost::thread(SomeWork,x,i);
        Sleep(10);
    }
Sleep(6000);
    system("PAUSE");
  return 0;
}

every time a letter (A to D) and the identifier genereaion (i) are passed to SomeWork as a stream. I don’t care about the order of execution between letters, but for an essential letter, say, A, Ax must start before Ay, if x <y. random part of random code output:

B0 started  
D1 started  
C2 started  
A3 started  
B0 finished  
B12 started  
D1 finished  
D15 started  
C2 finished  
C6 started  
A3 finished  
A9 started
B12 finished
B11 started -> B11 started after B12 finished.
D15 finished
D13 started
C6 finished
C7 started
A9 finished

How to avoid such conditions?
thank.

, . . , for. , . , , .
-, , for-loop 350 i, . 310 , . , , . ? -, visual studio 2008, . ( 1 3 ), . ?

:

#include <iostream>
#include <Windows.h>
#include <boost/thread.hpp>

using namespace std;

boost::mutex mutexA;
boost::mutex mutexB;
boost::mutex mutexC;
boost::mutex mutexD;


class cl
{
public:
    boost::condition_variable con;
    boost::mutex mutex_cl;
    char Letter;
    int num;
    cl(char letter) : Letter(letter) , num(0)
    {

    }
    void doWork( int index, int tracknum)
    {
        boost::unique_lock<boost::mutex> lock(mutex_cl);
        while(num != tracknum)     // line 1
            con.wait(lock);   // line 2 
        Sleep(10);
        num = index;
        cout << Letter<<index << endl; 
        con.notify_all();  // line 3
    }
};

int main(int argc , char * argv[])
{
    cl A('A');
    cl B('B');
    cl C('C');
    cl D('D');

    for(int i = 0; i < 100; i++)
    {   
        boost::thread(&cl::doWork,&A,i+1,i);
        boost::thread(&cl::doWork,&B,i+1,i);
        boost::thread(&cl::doWork,&C,i+1,i);
        boost::thread(&cl::doWork,&D,i+1,i);
    }
    cout << "************************************************************************" << endl;

    Sleep(6000);
    system("PAUSE");
  return 0;
}
+5
3

, , , , . , , . , B10 , , , B11 B12. B10 - , B11 B12, , , , .

, , 4 , ? . , .

+6

, B11 B12, SomeWork() B12. .

, ( ).

"" , . . , /. / .

+2

, . B12 B0 B11. - . .

. , SomeWork(), notify_all() condition. , . , . SomeWork().

You need a way for each thread to determine if it has incomplete dependencies. It will probably be some kind of globally accessible entity. You should only change it if you have a mutex (in SomeWork ()). Multiple-stream reading should be safe for simple data structures.

+1
source

More articles:


All Articles