Best way to control access to a string object in multi-threaded program

Vote count:

0

I've got a "config" class that has a bunch of attributes that "mirror" configuration settings. A single instance of the class is shared throughout the code (using boost shared_ptr objects) and its attributes read by multiple threads (around 100).

Occasionally, the settings may change and a "monitor" thread updates the appropriate attributes in the object.

For integer and bool attributes, I'm using boost atomic so that when an update happens and the monitor thread sets the value, none of the read threads read it in a partially updated state.

However, for string attributes, I'm worried that making them atomic would hurt performance significantly. It seems like a good way to do it would be to have the string attributes actually be pointers to strings, and then when an update happens, a new string object could be built, and then the write to the shared object (the string pointer) would only be writing the address of the new string object to point to. So I assume that write time would be far shorter than writing a whole new string value to a shared string object.

Doing that, however, means I think I'd want to use shared_ptrs for the string attribs, so that a string object holding the previous value is automatically deleted once all read threads are using the updated string pointer attribute.

So to give an example:

class Config
{
  public:
    boost::atomic<boost::shared_ptr<std::string> > configStr1;

    void updateValueInMonitorThread(std::string newValue)
    {
        boost::shared_ptr<string> newValuePtr;
        newValuePtr = newValue;
        configStr1 = newValuePtr;
    }
};

void threadThatReadsConfig(boost::shared_ptr<Config> theConfig)
{
    std::map<std::string, std::string> thingImWorkingOn;
    thingImWorkingOn[*(theConfig->configStr1.load())] = "some value";
}

Is that overkill? Is there a better way to do it? I really don't like the way the reading threads have to access the value by dereferencing it and calling .load(). Also, is it even threadsafe, or does that stuff actually negate the safety features of the atomic and/or shared_ptr type?

I know I could use a mutex and read lock it when accessed in a "getter" and write lock it when the monitor thread updates the string's value, but I'd like to avoid that as I'm trying to keep the config class simple and it's going to have dozens, possibly hundreds of these string attributes.

Thanks in advance for any suggestions/info!

asked 1 min ago

Brent212

120

Best way to control access to a string object in multi-threaded program