2

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

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

如果我与本机类对象进行互操作，这个问题将很容易解决。垃圾收集器无法在我背后（并且未经我的许可）释放这些对象。所以当我的托管对象的终结器被调用时，我知道我的内部状态仍然有效。

我需要的是一种告诉垃圾收集器不要动手的方法。

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

例如

例如，下面的代码是有缺陷的，因为终结器错误地认为私有_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
      }
   }
}

注意：它也可能由于伪记录行为而失败。从关于 GCHandles 的真相：

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

强调我的。

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

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

棘手的部分是我不拥有的类的内部私有成员；即使一个仍然被引用的对象GCAlloc也仍然有它所依赖的对象在它的背后最终确定。

示例使用

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

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

1 回答 1

0

无论如何，在最终确定期间执行任何长期操作（例如输入输出）都是一种非常糟糕的做法。您应该考虑将对象的 _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.：如果域可能在您不希望的情况下关闭，您唯一的方法是将值存储在另一个域中。

于 2014-01-02T22:37:38.620 回答