Question

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?

Answer 1

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