do
  let x = System.WeakReference(Array.create 0 0)
  for i=1 to 10000000 do
    ignore(Array.create 0 0)
  if x.IsAlive then "alive" else "dead"
  |> printfn "Weak reference is %s"

该堆分配一个立即适合垃圾回收的空数组。然后我们循环 10M 次分配更多无法访问的数组。请注意，这根本不会增加内存压力，因此没有动力收集弱引用引用的数组。然而程序打印“弱引用已死”，因为它仍然被收集。这是弱引用的行为。软引用将一直保留到实际需要其内存为止。

这是另一个测试程序（F# 代码）：

open System

let isAlive (x: WeakReference) = x.IsAlive

do
  let mutable xs = []
  while true do
    xs <- WeakReference(Array.create 0 0)::List.filter isAlive xs
    printfn "%d" xs.Length

它不断过滤掉无效的弱引用，并将新的弱引用添加到链表的前面，每次打印出列表的长度。在我的机器上，幸存的弱引用永远不会超过 1,000 个。它会循环上升然后下降到零，大概是因为在每个 gen0 收集中都会收集所有弱引用。再次强调，这是弱引用而不是软引用的行为。

请注意，这种行为（在第 0 代集合中积极收集弱引用对象）正是使弱引用成为缓存的糟糕选择的原因。如果您尝试在缓存中使用弱引用，那么您会发现缓存无缘无故地被大量刷新。

Are C# weak references in fact soft?

No.

am I wrong there?

You are wrong there. The purpose of weak references is absolutely not caching in the sense that you mean. That is a common misconception.

are they able to expand lifetime, or do they behave like true weak refs?

No, they do not expand lifetime.

Consider the following program (F# code):

do
  let x = System.WeakReference(Array.create 0 0)
  for i=1 to 10000000 do
    ignore(Array.create 0 0)
  if x.IsAlive then "alive" else "dead"
  |> printfn "Weak reference is %s"

This heap allocates an empty array that is immediately eligible for garbage collection. Then we loop 10M times allocating more unreachable arrays. Note that this does not increase memory pressure at all so there is no motivation to collect the array referred to by the weak reference. Yet the program prints "Weak reference is dead" because it was collected nevertheless. This is the behaviour of a weak reference. A soft reference would have been retained until its memory was actually needed.

Here is another test program (F# code):

open System

let isAlive (x: WeakReference) = x.IsAlive

do
  let mutable xs = []
  while true do
    xs <- WeakReference(Array.create 0 0)::List.filter isAlive xs
    printfn "%d" xs.Length

This keeps filtering out dead weak references and prepending a fresh one onto the front of a linked list, printing out the length of the list each time. On my machine, this never exceeds 1,000 surviving weak references. It ramps up and then falls to zero in cycles, presumably because all of the weak references are collected at every gen0 collection. Again, this is the behaviour of a weak reference and not a soft reference.

Note that this behaviour (aggressive collection of weakly referenced objects at gen0 collections) is precisely what makes weak references a bad choice for caches. If you try to use weak references in your cache then you'll find your cache getting flushed a lot for no reason.

回复收藏 0 原文