(CopyOnWrite)在多线程环境中的陷阱（四）

(CopyOnWrite)在多线程环境中的陷阱（一）

(CopyOnWrite)在多线程环境中的陷阱（二）

(CopyOnWrite)在多线程环境中的陷阱（三）

最简单的办法就是我们去掉strLog，将整个OnAddText直接使用互斥段进行保护，
LRESULT CEditLog::OnAddLog(WPARAM, LPARAM)
{
  m_mutex.Lock();
  ...
  SetWindowText(m_strStore.c_str());
  .....
  m_mutex.Unlock();
}
但是这样无疑带来了锁被长时间占用，效率不高。

 

另外一种可以马上想到的方法就是“深层地拷贝”m_strStore对象，即迫使m_strStore和strLog之间不共享字符串，这个比较容易实现，只需要strLog＝m_strStore.c_str()即可，锁的占用时间也小。但是也带了了一个问题，就是字符串总是复制了两份，内存消耗了。
LRESULT CEditLog::OnAddLog(WPARAM, LPARAM)
{
  std::string strLog;
  m_mutex.Lock();
  strLog = m_strStore.c_str();      //迫使strLog和m_strStore不共享字符串
  m_mutex.Unlock();

   .....
  SetWindowText(strLog.c_str());
  .....
}

 

有没有更好的解决方案呢？

其实再回头来看看我们出现问题的情况，我们可以发现，在我们这种特定的情况中，strLog在主线程中只是“只读”的使用，仅仅是最后调用析构函数的时候需要保护。因此只要我们将strLog的析构函数也至于同一个互斥段的保护之下，那么就完全可以避免这个问题。这种实现，既不长时间占用锁，也无需在不必要的情况下消耗额外的内存。具体如何实现呢？最先我想到的方法就是（当然不是去修改std::string的源代码啦），利用C++的栈上局部变量析构的次序来实现。

首先，我们创建两个class，一个DestructUnlock，析构的时候调用m_mutex.Unlock，一个Destructlock，析构的时候调用m_mutex.Lock, 然后，将我们定义std::string strLog的语句夹在这两个对象的定义之间。如下所示：

LRESULT CEditLog::OnAddLog(WPARAM, LPARAM)
{
 DestructUnlock unlock(m_mutex);
 std::string strLog;
 Destructlock  lock(m_mutex);

 m_mutex.Lock();
 strLog = m_strStore;
 m_mutex.Unlock();
 
 .....
 SetWindowText(strLog.c_str());
   
}

这样，当函数退出的时候，会依次调用
1. Destructlock的析构函数，使得m_mutex.Lock被调用
2. strLog的析构函数，由于m_mutex已经Lock，保证了m_strStore的+=操作不会发生。
3. DestructUnlock的析构函数，释放m_mutex锁。

虽然解决了我们的问题，但是实在是麻烦，还要定义两个class（虽然很容易将它们合并成一个）。

又考虑了一下，其实利用C++的｛｝就可以保护一个对象的析构函数，因此，下面的是我最后的解放方案。

LRESULT CEditLog::OnAddLog(WPARAM, LPARAM)
{
 {
   std::string strLog;
   m_mutex.Lock();
   strLog = m_strStore;
   m_mutex.Unlock();

    .....
   SetWindowText(strLog.c_str());
 
    m_mutex.Lock();
 }  //隐含的strLog的析构函数被至于互斥段保护之下
 m_mutex.Unlock();
}

（完）

本文地址：http://com.8s8s.com/it/it28773.htm