3

我遇到了微软提供的这种一次性模式的实现：https ://msdn.microsoft.com/en-us/library/system.idisposable(v=vs.110).aspx

using System;

class BaseClass : IDisposable
{
   // Flag: Has Dispose already been called?
   bool disposed = false;

   // Public implementation of Dispose pattern callable by consumers.
   public void Dispose()
   { 
      Dispose(true);
      GC.SuppressFinalize(this);           
   }

   // Protected implementation of Dispose pattern.
   protected virtual void Dispose(bool disposing)
   {
      if (disposed)
         return; 

      if (disposing) {
         // Free any other managed objects here.
         //
      }

      // Free any unmanaged objects here.
      //
      disposed = true;
   }

   ~BaseClass()
   {
      Dispose(false);
   }
}

假设我有一个与此 C# 类关联的 C++ 类，并且我想delete在处置 C# 类时使用 C++ 对象以确保正确释放我的非托管资源。我添加了一个函数DestructNative(self)，它基本上delete (CppObject*)self对关联的 C++ 对象进行本机 C++ 调用。所以我的代码如下所示：

   // Protected implementation of Dispose pattern.
   protected virtual void Dispose(bool disposing)
   {
      if (disposed)
         return; 


      if (disposing) {
         // Free any other managed objects here.
         //
      }

      DestructNative(self);
      disposed = true;
   }

Dispose(false)所以我的问题是，知道可以从不同的线程调用 C# 终结器，我是否需要在 C++ 对象的析构函数中提供同步，以确保从 C# 终结器调用时没有任何竞争条件？

附加问题

微软一次性模式坏了吗？似乎disposed标志是一个简单的变量，如果从不同的线程调用终结器，则该变量不同步。

4

1 回答 1

2

微软一次性模式坏了吗？似乎已处置标志是一个简单的变量，如果从不同的线程调用终结器，则该变量不同步。

不，它没有坏。

这个问题提出了两个有趣的问题。对于一个早于C++11思考并且线程不知道的类，以下的影响是什么。

 class PreCpp11 {
   public:
     int ** ptr;
     bool   mInitDone;
     PreCpp11() : mInitDone(false) {
         ptr = new int*[100];
     }
     init() {
         for( size_t i = 0; i < 100; i++ ){
             ptr[i] = new int[100];
         }
         mInitDone = true;
     }
     ~PreCpp11() {
        if( mInitDone ){
            for( size_t i =0; i <100; i++ ){
                delete ptr[i];
            }
        }
        delete []ptr;
     }
 }

代码之后

PreCpp11 * myObj = new PreCpp11();
myObj->init();
send_object_to_thread2( myObj );

线程 2 执行的位置

 PreCpp11 obj = get_obj_from_sync();
 delete obj;

如果在不同的线程上调用析构函数，我们如何避免数据竞争。

鉴于对于一次性实施，这是否会导致如上所述的数据竞争。

在这两种情况下，我相信这个代码的答案是可以接受和合规的。但是，它依赖于 PreCpp11 对象的线程间通信来使其自身兼容。

我的想法……

我有一大堆数据竞争机会，这个线程保证能看到我写入 ptr 数组的值，但其他线程不能保证inter-thread happens-before关系已经发生。

但是，当我在线程间与第二个线程通信我的类时，为了确保我的指针在启动线程和“处理”线程之间正确同步而发生的同步，创建了一个inter-thread happens-before关系，这发生在我调用之后init，线程 2 中看到的值是线程 1 在开始与第二个线程通信时看到的值。

因此，如果线程 1 在将对象提供给线程 2 后继续修改对象，则可能会发生数据竞争，但假设线程之间的通信是合规的，那么第二个线程会看到第一个行为。

从cppreference memory_order

先排序

 ->init() is sequenced before 
 send_object_to_thread2( myObj );

发生在之前

->init() happens before the synchronized communication with thread2.

线程间发生之前

->init() happens before thread 2 gets the data and calls the destructor
 ->init() is sequenced-before the synchronized write to the inter-thread communication, and the write occurs before the synchronized read.
 The actual write-read is ordered, as they are synchronized.

因此，只要对象的线程间通信是同步的，并且在切换到新线程后没有进一步修改对象，就不存在数据竞争。

于 2017-08-26T07:42:55.370 回答