STL中的boost :: upgrade_to_unique_lock等效于什么？

Question

I'm trying to replace the boost functionalities with STL functinoalities in C++11. There is a write function in my multi-thread application.

First, the function verifies the data. Next, writes to it. There are two locks mentioned as mentioned below:

class Data
{
    mutable boost::mutex mut;
    void Data::Write()
    {
        boost::upgrade_lock<boost::shared_mutex> ulock(mut);
        // ... Verification statements

        boost::upgrade_to_unique_lock<boost::shared_mutex> lock(ulock);
        // ... Writing statements
    }
};

I'm a novice of boost functionalities. Can you please explain what it does and how I can achieve the functionality with STL features?

Answer 1

C++11 doesn't provide shared locks at all. C++14 does, but doesn't allow them to be upgraded to exclusive locks; you'd need a second mutex for that, something like:

mutable std::shared_timed_mutex read_mutex;
std::mutex write_mutex;

void Write() {
    std::shared_lock read_lock(read_mutex);
    // ... Verification statements

    std::lock_guard write_lock(write_mutex);
    // ... Writing statements
}

You'll need to take some care only to acquire the write lock while already holding the read lock, to avoid deadlocks. If you have a working Boost solution, it might be better to stick to that until the standard library provides equivalent functionality.

Answer 2

In C++ threads you get:

#include <thread>
#include <mutex>

using namespace std;

mutex mu;

// lock_guard: acquire the mutex mu and lock it. when the lock_guard object goes out of scope, mutex is unlocked.
lock_guard<mutex> lock(mu);

// more flexible than the lock_guard
// http://en.cppreference.com/w/cpp/thread/unique_lock
unique_lock<mutex> ulock(mu);
ulock.unlock();
ulock.lock();