http://www.thehotstop.info

signature…

Boost.Threads on Unix systems is layered on top of POSIX threads, i.e. boost::thread::join() calls pthread_join() which is not thread-safe:

“The results of multiple simultaneous calls to pthread_join() specifying the same target thread are undefined.” (http://www.opengroup.org/onlinepubs/007908799/xsh/pthread_join.html)

So we need a mutex to synchronize thread access in operator()().

The other issue is that joining the thread requires that the thread is joinable, i.e. join() should be called only once.

With these issues in mind we could add a mutex lock to operator()() and ensure that join() is called exactly once, e.g.

template
T future::operator()()
{
mutex::scoped_lock lock(m_);
if (!joined_) {
t_.join();
joined_ = true;
}
return v_;
}

where the instance variable ‘joined_’ is a simple boolean value initialized to false.

Other than that I like this version using join(). It does away the additional lock, the enum and the busy wait – thanks again.

template
class future : boost::noncopyable
{
public:
explicit future(function const & f) : v_(), f_(f), t_(boost::bind(&future::run(), this)) {}
T operator()() { t_.join(); return v_; }

private:
void run() { v_ = f_(); }

T v_;
function f_;
thread t_;
};

You see: thread.join() implements the thread state synchronization for you. op() just join()s and returns v_.