Using two boost mutexes in one method?

Question

I have a situation where I have 3 threads involved. Let's call them A, B, and C. Thread A and B share static data within the same class. Thread C also could potentially be using the same static data. So I created two mutexes. One mutex covers thread A and B sharing data with each other. Another mutex takes care of thread A and C sharing data. One mutex is a boost scoped_lock and another mutex is a lock_guard. Am I doing the right thing here? Basically, some of the methods end up looking like this:

      bool CMBTmlBroker::GetTheDatasetListFromTheMB(const std::string &strDatasetTypeShortDisplayName /* use GetTheDatasetTypeShortDisplayName() */,
        const std::string &strDatasetType /* can be blank */,
        const std::string &strProduct /* can be blank */)
      {
        boost::recursive_mutex::scoped_lock scoped_lock(GetLock());

        boost::lock_guard<boost::mutex> DBDatasetKey2DBDatasetInfoMutex(m_DBDatasetKey2DBDatasetInfoMutex);

...

I want a solution with performance being the biggest concern.

"Thread C also could potentially be using the same static data". When thread C accesses the data while B modifies them, does shit happen? You need one mutex per protected data object, not one per thread pair. — thiton
mutex assures mutual exclusion between any number of threads. it guarantees that only one thread will be active in the area between lock-----unlock. Now, you do not need to worry which one of how many is active because no matter what there will always be one thread accessing the critical code section. — Ramadheer Singh

James Brock James Brock · Accepted Answer · 2011-11-10T17:40:43

thiton is right, you should have "one mutex per protected data object, not one per thread pair." Any shared writable data must be protected to allow only one thread at a time to modify, and there's no way around that.

Also, if you have lots of mutexes, you must be careful to always aquire and release them in the same order, or else you'll deadlock:

mutex MutexAB;
mutex MutexBC;

Thread A

scoped_lock lAB(MutexAB);
scoped_lock lBC(MutexBC);

Thread B

scoped_lock lBC(MutexBC);
scoped_lock lAB(MutexAB);

These threads will deadlock.

Using two boost mutexes in one method?

1 Answers