Question

So we have class with functions a and b. Thread one calls a and no other thread can call a or b untill one would call b. Meaning thread one would be capable to call a and than a and … and than a, and while one had not called b other threads that want to call a or b stand waiting. is it possible to do such thing with boost::mutex and how to do it?

Answer 1

The mutex is not a problem; it’s the lock. The simplest solution is
just to call mutex::lock() and mutex::unlock() manually, and forget
about the mutex::scoped_lock; after all, you don’t want the lock to
respect scope. The problem with this is the usual one; you probably
want to free the lock in case of an exception. One solution would be to
allocate the mutex::scoped_lock dynamically, and use a std::auto_ptr
or a boost::shared_ptr to manage it. (Curiously enough, neither
boost::mutex::scoped_lock nor std::lock_guard are movable, so you
need dynamic allocation in order to transfer ownership.)