Hello,

I would like to re-implement this (callback) function that currently uses pthreads:

pthread_mutex_t mutex;
int i = pthread_mutex_init(&mutex, 0);

void MutexCB(int lock)
{
if (lock)
pthread_mutex_lock(&mutex);
else
pthread_mutex_unlock(&mutex);
}

using the boost library (so the code will be portable).

The function is necessary in order to use some third party API.
It has to lock the mutex if 'lock' == true, unlock it otherwise.
It has to be thread safe as well.

I had difficulties since the scoped_lock is NOT thread safe, and the access to the mutex's do_lock()/do_unlock() methods is private.

Here is a solution that uses:
- recursive mutex,
- a static lock that gives the access to the lock/unlock mechanism
- another lock (on the stack) that makes the static lock thread safe

boost::recursive_mutex m;

void MutexCB(int lock)
{
boost::recursive_mutex::scoped_lock l(m); // it makes the 's'lock thread safe

   static boost::recursive_mutex::scoped _lock s(m, false /*lock only if necessary*/);
if (lock)
   s.lock();
   if (!lock)
   s.unlock();
   }

As you can see it is more complicated that the pthread solution and less efficient, since it does a extra lock/unlock every time.
Is it possible to write a solution at least as simple as the original one?

Regards,
Petru Marginean