Some boost thread questions C++

I am using boost::thread, and I meet开发者_如何学编程 some problems.

The thing is, are there any ways I can join a thread before the last join finish? for example,

int id=1;
void temp()
{
    int theardID = id++;
    for(int i=0;i<3;i++)
    {
        cout<<theardID << " : "<<i<<endl;
        boost::this_thread::sleep(boost::posix_time::millisec(100));
    }
}
int main(void)
{
    boost::thread thrd1(temp);

    thrd1.join();

    boost::thread thrd2(temp);
    boost::thread thrd3(temp);    
    thrd2.join();
    thrd3.join();   
    return 0;
}

In this simple example, the order of output may be:

1:0
1:1
1:2
2:0
3:0
3:1
2:1
2:2
3:2

As the above example, we can see find out that thrd2 and thrd3 start to run after thrd1 finish.

Are there any ways to let thrd2 and thrd3 run before thrd1 finish?

You can use Boost.Thread's condition variables to synchronize on a condition more complex than what join can provide. Here's a example based on yours:

#include <iostream>
#include <boost/thread.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition_variable.hpp>

boost::mutex mutex;
boost::condition_variable cond;

// These three variables protected by mutex
bool finishedFlag = false;
int finishedID = 0;
int finishedCount = 0;

int id=1;
void temp()
{
    int threadID = id++;
    for(int i=0;i<3;i++)
    {
        std::cout << threadID << " : " << i << std::endl;
        boost::this_thread::sleep(boost::posix_time::millisec(100));
    }

    {
        boost::lock_guard<boost::mutex> lock(mutex);
        finishedFlag = true;
        finishedID = threadID;
        ++finishedCount;
    }
    cond.notify_one();
}

int main(void)
{
    boost::thread thrd1(temp);
    boost::this_thread::sleep(boost::posix_time::millisec(300));
    boost::thread thrd2(temp);
    boost::thread thrd3(temp);

    boost::unique_lock<boost::mutex> lock(mutex);
    while (finishedCount < 3)
    {
        while (finishedFlag != true)
        {
            // mutex is released while we wait for cond to be signalled.
            cond.wait(lock);

            // mutex is reacquired as soon as we finish waiting.
        }
        finishedFlag = false;

        if (finishedID == 1)
        {
            // Do something special about thrd1 finishing
            std::cout << "thrd1 finished" << std::endl;
        }
    };

    // All 3 threads finished at this point.

    return 0;
}

The join function means "stop this thread until that thread finishes." It's a simple tool for a simple purpose: ensuring that, past this point in the code, thread X is finished.

What you want to do isn't a join operation at all. What you want is some kind of synchronization primitive to communicate and synchronize behavior between threads. Boost.Thread has a number of alternatives for synchronization, from conditions to mutexes.