弱引用终结器保证运行

Question

In The cost of weak pointers and finalizers in GHC , Edward Yang writes (emphasis added):

A weak pointer can also optionally be associated with a finalizer, which is run when the object is garbage collected. Haskell finalizers are not guaranteed to run.

I cannot find any documentation that corroborates this claim. The docs in System.Mem.Weak are not explicit about this. What I need to know is, given some primitive that has identity ( MutVar# , MutableArray# , Array# , etc.), if I attach a finalizer to it, will it reliably be called when the value gets GCed?

The reason is that I'm considering doing something like this:

data OffHeapTree = OffHeapTree
  { ref :: IORef ()
  , nodeCount :: Int
  , nodeArray :: Ptr Node
  }

data Node = Node
  { childrenArray :: Ptr Node
  , childrenCount :: Int
  , value :: Int
  }

I want to make sure that I free the array (and everything the array points to) when an OffHeapTree goes out of scope. Otherwise, it would leak memory. So, can this be reliably accomplished with mkWeakIORef or not?

Answer 1

"Haskell finalizers are not guaranteed to run" means that GC may not be performed (eg on program exit). But if GC is performed, then finalizers are executed.

Edit: For future readers: the statement above is not exactly correct. RTS spawns a separate thread to execute finalizers after GC. So the program may exit after GC is performed, but finalizers are not yet executed, see this comment .

That is true in theory anyway. In practice finalizer may not be executed , eg when RTS tries to execute a number of finalizers in a row, and one of then throws an exception. So I'd not use finalizers unless it is unavoidable.