How to obtain an exclusive lock *first* and then downgrade to shared without releasing the lock

Question

Stack Overflow has several examples where a function obtains an upgradeable lock first and then obtains exclusive access by upgrading. My understanding is that this can cause deadlocks if not used carefully since two threads may both obtain the upgradeable/shared lock and then both attempt to upgrade, at which point neither can proceed because the other has a shared lock.

What I want is to obtain the exclusive lock first and then downgrade to a shared lock without releasing the lock completely. I cannot find an example of this. Any ideas?

Answer 1

Boost offers this functionality through the UpgradeLockable concept. The method you are looking for is unlock_and_lock_shared().

An implementation of this concept is provided by the upgrade_mutex class.

Answer 2

It seems the proper way to do this using lock adapters should be something like this:

boost::shared_mutex mtx;

void exclusive_to_shared( )
{
    boost::unique_lock< boost::shared_mutex > unique_lock( mtx );

    // The lock here is exclusive.

    boost::shared_lock< boost::shared_mutex > shared_lock( std::move( unique_lock ) );

    // The lock here is shared.
}

There's an explicit conversion defined from unique_lock's RV refs to shared_lock which calls the unlock_and_lock_shared( ). See this e-mail thread and the source.