引用计数类和多线程

Question

我是多线程编程的新手，我仍然对此感到困惑。

下面是我的引用计数类：

class Rbuffer
{
  private:
    char *m_pnData;
    volatile unsigned int mRefCount;

  public:
     Rbuffer(int nLength) : mRefCount(0)
    {
    m_pnData = new char[nLength]; 
    }
   ~Rbuffer(){
    delete[] m_pnData;
    }

   void decRef() {
     if(InterlockedDecrement(&mRefCount)==0){
               delete (Rbuffer *)this;
           }
    }

  void incRef() {
        InterlockedIncrement(&mRefCount);
    } 

}; 

它是完全线程安全的吗？你能排除这种情况吗：

ThreadA                                 ThreadB
PointerToRBuffer->incRef();//mRefCount 1
switch->  
                                        PointerToRBuffer->incRef();//mRefCount 2
                                          <-switch
PointerToRBuffer->decRef();           
InterlockedDecrement(&mRefCount)//mRefCount 1 
switch->                                
                                        PointerToRBuffer->decRef();//mRefCount 0!
                                        InterlockedDecrement(&mRefCount);
                                        if (0==0)
                                        delete (Rbuffer *)this; 
                                            <-switch
if (0==0) 
//deleting object, that doesn't exist 
delete (Rbuffer *)this;
//CRASH                               

崩溃的原因可能是只有 (InterlockedDecrement(&mRefCount)) 部分是原子的，但 if (InterlockedDecrement(&mRefCount)==0) 不是？ 我上面的例子错了吗？

提前感谢您的意见和建议，以使我的课程完全线程安全。

Answer 1

您的分析不正确；您发布的代码正确使用了interlockedDecrement。

这是一个安全的使用

 if(InterlockedDecrement(&mRefCount)==0)
           cleanup();

..但这确实会出现您描述的问题

 InterlockedDecrement(&mRefCount);

 if (mRefCount==0)
           cleanup();

但是，delete this 的使用更可能是问题的原因。您不太可能通过此处描述的“绝对肯定 100% 肯定”测试： http://www.parashift.com/c++-faq-lite/delete-this.html

尤其是下面的简单代码会造成混乱。

{
  RBuffer x;  // count is what... ? zero
  x.incRef(); // make count one
  x.decRef(); // make count zero, and deletes itself 
}  // now x goes out of scope, so destructor is called a second time = chaos! 

一个普通的“引用计数”习语涉及一个“共享对象”（带有计数）和简单的“引用对象”（不是 C++ 引用，尽管语义相似），它们引用共享对象。 “引用对象”的构造函数和析构函数负责调用共享对象上的incref/decref 方法。所以共享对象会自动计算活动“引用对象”的数量。

Answer 2

目前还不是 100% 清楚发生了什么，但看起来 ThreadA 删除了 RBuffer 对象，然后 ThreadB 取消了它的引用。

您真正需要的是关于减量和删除操作的互斥，此外您需要设置某种标志以防止删除后取消引用。通常将指针设置为 NULL 是可行的，然后在取消引用之前检查 NULL。

所以你的 decRef 可能看起来像这样：

 void decRef() {
     lock(_mutex);
     if(InterlockedDecrement(&mRefCount)==0) {
               PointerToRBuffer = NULL;
               delete (Rbuffer *)this;
           }
    }

使用 shared_ptr 可能会更好。