使用GCAlloc.Alloc（）

Question

在为期两周的解决问题的过程中：

根本问题是垃圾收集器。当对象即将被释放时（即回收其资源），我的对象的 Finalizer 将是理想的反应时间。 .NET垃圾收集系统的问题在于，当调用 my 终结器时，我所拥有的其他对象很可能已经完成。

如果我使用 native 类对象进行交互，那么问题就很难解决。垃圾收集器无法释放我背后的这些对象（未经我的许可）。所以当我的托管对象的终结器被调用时，我知道我的内部状态仍然有效。

我需要的是告诉垃圾收集器保持双手的方法。

有没有办法防止对象被最终确定？

例如

例如，以下代码是错误的，因为终结器错误地认为私有_values对象仍然存在。实际上，它很可能已经从我身下完成了：

class Sqm
{
   private List<Value> _values = new List<Value>();

   //finalizer
   public ~Sqm()
   {
       Shutdown();
   }

   protected void Shutdown()
   {
      foreach (var value in _values)  //<-- crash; _values no longer exists
         SaveValueToHardDrive(value); //<-- crash; value no longer exists
   }
}

我需要的是告诉垃圾收集器 而不是 来完成列表对象或其中的任何对象的方法：

class Sqm
{
   private List<Value> _values = new List<Value>();

   //constructor
   public Sqm()
   {
      GC.LetMeManuallyFinalize(_values);
   }

   //finalizer
   public ~Sqm()
   {
       Shutdown();
       GC.ManuallyFinalize(_values);
   }

   protected void Shutdown()
   {
      foreach (var value in _values) 
         SaveValueToHardDrive(value);
   }
}

这有两个可能的问题：

没有GC.ManuallyFinalize方法

它可能会禁止释放_values列表本身，但它引用的对象可能仍会在我背后完成：

  protected void Shutdown()
  {
     foreach (var value in _values) 
        SaveValueToHardDrive(value); //<---crash, contained object already finalized
  }

所以现在我需要确保添加到列表中的对象也被排除在最终化之外：

public void AddSample(String name, Int64 value)
{
    Entry entry = GetEntryByName(name);
    if (entry == null)
    {
       entry = new Entry();
       GC.LetMeManuallyFinalize(entry);
    }

    entry.Count += 1;
    entry.Sum += value;
    entry.Average = entry.Sum / entry.Count;
}

//finalizer
public ~Sqm()
{ 
   foreach (var value in _values)
      GC.ManuallyFinalize(value);

   GC.ManuallyFinalize(_values);      
}

这可能有问题，虽然Entry没有其他内部对象，但我不知道List<T>。尽管_values本身尚未最终确定，垃圾收集器可能会在_values上执行不需要的切割术。

使用GCAlloc.Alloc（）

@MatthewWatson有个好主意。我认为指出为什么这是错的是有用的。使用GCAlloc.Alloc保存对象的引用。然后你可以在终结器中使用它来访问它：

public Sqm()
{
   private List<Value> _values = new List<Value>();
   private GCHandle _valuesHandle; //handle to keep _values alive

   //constructor
   Sqm()
   {
      //prevent _values from being finalized
      _valuesHandle = GCAlloc.Alloc(_values); 
   }

   //finalizer
   ~Sqm()
   {
      try
      {
         Shutdown(_values); //Safe, right? RIGHT? _values couldn't have been finalized
      } 
      finally
      {
         _valuesHandle.Free();
      }
   }

   private void Shutdown(List<Values> values)
   {
      foreach (var value in values)
      {
         //The list itself might not have been finalized
         //But objects used internally to Microsoft's List<T> class have been finalized
         //and objects in the list itself were already finalized
         SaveValueToHardDrive(value); //<--BAD: values inside list were already finalized
      }
   }
}

注意：由于伪记录的行为，它也可能失败。来自The Truth About GCHandles：

创建新GCHandle时，会在AppDomain的句柄表中创建一个新条目。保留此条目，直到释放句柄（通过GCHandle.Free()）或卸载AppDomain 。

强调我的。

所以这就是了。我需要告诉垃圾收集器

不要最终确定此对象（及其中的所有内容）

棘手的部分是我不拥有的班级的内部私人成员;即使是GCAlloc仍然引用的对象仍然会有依赖于它背后最终确定的对象。

样本用法

public static Foo
{
   public static Sqm = new Sqm();
}

Foo.Sqm.AddSample("QueryCustomerInfo", stopwatch.TotalMicroseconds);

Answer 1

无论如何，在最终确定期间进行任何长期操作都是非常糟糕的做法，例如输入输出。您应该考虑将对象的_values列表存储在静态列表中 - 这样可以防止值被破坏。当您的对象正在最终化时，您可以将对内部列表的引用保存在另一个静态列表中，该列表会定期检查。当它包含对列表的引用时，它将意味着您的对象被破坏，并且应该保存它包含的值。

class Sqm
{
  private static List<List<Value>> = _lists = new List<List<Value>>();
  private static List<List<Value>> = _finalizationQueue = new List<List<Value>>();
  private List<Value> _values = new List<Value>();
  Sqm() { _lists.Add(_values); }
  ~Sqm() { _finalizationQueue.Add(_values); }
  public static void CheckAndSave()
  {
    foreach(var list in _finalizationQueue)
      SaveValues(list);
  }
}

UPD。：如果域名可能在您不想要时关闭，您唯一的方法是将值存储在另一个域中。

如何阻止对象（及其中的所有内容）被最终确定？

例如

使用GCAlloc.Alloc（）

样本用法

1 个答案: