Question

I have some status data that I want to cache from a database. Any of several threads may modify the status data. After the data is modified it will be written to the database. The database writes will always be done in series by the underlying database access layer which queues database operations in a different process so I cam not concerned about race conditions for those.

Is it a problem to just modify the static data from several threads? In theory it is possible that modifications are implemented as read, modify, write but in practice I can’t imagine that this is so.

My data handling class will look something like this:

class StatusCache { public:     static void SetActivityStarted(bool activityStarted)         { m_activityStarted = activityStarted; WriteToDB(); }     static void SetActivityComplete(bool activityComplete);         { m_activityComplete = activityComplete; WriteToDB(); }     static void SetProcessReady(bool processReady);         { m_processReady = processReady; WriteToDB(); }     static void SetProcessPending(bool processPending);         { m_processPending = processPending; WriteToDB(); } private:     static void WriteToDB(); // will write all the class data to the db (multiple requests will happen in series)     static bool m_activityStarted;     static bool m_activityComplete;     static bool m_processReady;     static bool m_processPending; }; 

I don’t want to use locks as there are already a couple of locks in this part of the app and adding more will increase the possibility of deadlocks.

It doesn’t matter if there is some overlap between 2 threads in the database update, e.g.

thread 1                        thread 2                    activity started in db SetActivityStarted(true)        SetActivityStarted(false)      m_activityStated = true                                   m_activityStarted = false                                   WriteToDB()               false   WriteToDB()                                               false 

So the db shows the status that was most recently set by the m_… = x lines. This is OK.

Is this a reasonable approach to use or is there a better way of doing it?

[Edited to state that I only care about the last status – order is unimportant]

Answer 1

No, it’s not safe.

The code generated that does the writing to m_activityStarted and the others may be atomic, but that is not garantueed. Also, in your setters you do two things: set a boolean and make a call. That is definately not atomic.

You’re better off synchronizing here using a lock of some sort.

For example, one thread may call the first function, and before that thread goes into ‘WriteDB()’ another thread may call another function and go into WriteDB() without the first going there. Then, perhaps the status is written in the DB in the wrong order.

If you’re worried about deadlocks then you should revise your whole concurrency strategy.