Question

There is a sample code which “works” in a multithreading environment:

void CSampleClass::Stop(void) {
  if (m_pDB != nullptr) {
  ... Here is some code
    m_pDB->Interrupt();
  }
}

, where the m_pDB member is declared as boost::shared_ptr<CSampleDatabase> m_pDB;. m_pDB can be reset in another class method. That is why it is tested to not nullptr. As the code have multiple threads, can be a situation when m_pDB is reset, by another thread, in between if (...) and m_pDB->Interrupt();. The result is quite dramatic. To prevent such situation I use the following code modification

void CSampleClass::Stop(void) {
  auto pDb = m_pDB; //lock
  if (pDb != nullptr) {
  ... Here is some code
    pDb->Interrupt();
  }
}

, i.e. if m_pDB.reset(); called, the object is never released until pDb is destroyed.

The questions are:

1. Is there a “standard” way to prevent the situation without involving lockers, mutexes, critical sections, etc.? Something like using boost::weak_ptr to break circular references.

2. Is it guaranteed that the compiler declares pDB as boost::shared_ptr<CSampleDatabase> and not CSampleDatabase *? May be it is safer to write decltype(m_pDB) pDb = m_pDB; //lock?

Answer 1

The solution presented is not safe. It is similar to this example from the documentation:

// thread A
p = p3; // reads p3, writes p

// thread B
p3.reset(); // writes p3; undefined, simultaneous read/write

Simultaneous reads from the same instance are safe. Any other concurrent operations on the same instance are not.

Is there a “standard” way to prevent the situation without involving lockers, mutexes, critical sections, etc.? Something like using boost::weak_ptr to break circular references.

You need mutual exclusion, so you need to use a mutual exclusion construct.

Is it guaranteed that the compiler declares pDB as boost::shared_ptr<CSampleDatabase> and not CSampleDatabase *? May be it is safer to write decltype(m_pDB) pDb = m_pDB; //lock?

Yes, pDB will be a shared_ptr.