Question

I’m trying to write a class that allows data to be access by multiple readers or just one writer. The problem is that a reader can conditionally become a writer and I want to ensure that no matter how many threads want to be writers only one is allowed to be, and the other threads wait for the writer to finish and are changed back to readers.

The problem is at the if(condition) statement, since this could be evaluated as true by multiple threads, causing them to all try to become writers even though the data only needs to be written once.

class Test {
public:
    int getData() {
        boost::shared_lock<boost::shared_mutex> lock(access_);

        if(condition) {
            writeData();
        }

        // Do stuff
    }

    void writeData() {
        // Get exclusive access
        boost::upgrade_to_unique_lock<boost::shared_mutex> unique_lock(access_);

        // Do stuff
    }

private:    
    boost::shared_mutex access_;
}

Answer 1

So I got this working in an acceptable fashion. Basically I release the shared lock if a write is needed, and then the write function will get a unique lock. After getting the unique lock in the write function, it checks again to make sure that the write operation is still needed to handle the case where multiple threads think that they need to write to the data.

I know this isn’t ideal since the time spent waiting for a unique lock in multiple threads, when only one thread needs the unique lock. But, the performance is good enough for now, and is a significant improvement over how it was before.

class Test {
public:
    int getData() {
        boost::shared_lock<boost::shared_mutex> lock(access_);

        if(need_write) {
            lock.unlock();
            writeData();
            lock.lock();
        }

        // Do stuff
    }

    void writeData() {
        // Get exclusive access
        boost::unique_lock<boost::shared_mutex> unique_lock(access_);

        if(need_write) {
            return;
        }

        // Do stuff
    }
private:    
    boost::shared_mutex access_;
}