WeakReferences And Tracking Resurrection

clyon — Tue, 02 May 2006 03:23:00 GMT

The WeakReference class has two public constructors.

public WeakReference(Object target)

public WeakReference(Object target, bool trackResurrection)

The first parameter is pretty obvious. It’s the object you want the WeakReference to reference, without keeping the object alive. If a WeakReference is the only thing referencing an object, then the GC is free to collect the object. After the GC collects the object, WeakReference.IsAlive will return false, and WeakReference.Target will return null. The WeakReference loses its handle to the object as soon as the GC collects it but before the finalizer (if any) gets run. This is called a short WeakReference.

If the caller passes true as the trackResurrection parameter, then the WeakReference tracks the object’s life until finalization is complete. This is called a long WeakReference. If the object is resurrected, a long WeakReference will continue to reference it, where a short WeakReference will report it as dead.

The same distinction also applies to GCHandleType.Weak.

Why You Shouldn’t Rely On WeakReference.IsAlive

clyon — Fri, 21 Apr 2006 03:34:00 GMT

The WeakReference class has the property IsAlive. The problem with it, is that you can only trust it if it returns false.

While a WeakReference points to an object that is either live (reachable), or garbage (unreachable) that has not yet been collected by the GC, the IsAlive property will return true. After an object has been collected, if the WeakReference is short (or if the target object does not have a finalizer) then IsAlive will return false. Unfortunately by the time IsAlive returns, the target may have been collected.

This situation can occur because of the way the GC suspends all managed threads before scanning the heap for garbage and collects it (this is an oversimplified explanation for illustrative purposes). The GC can run at any time between two instructions. For example:

Foo f = new Foo();

WeakReference wr = new WeakReference(f);

// code goes here ...

if (wr.IsAlive)

{

// Garbage Collection may have occurred here!

Foo f2 = (Foo)wr.Target;

Console.WriteLine(f2.ToString());

}

If a collection occurred inside the if block, but before the WriteLine, this code would throw a NullReferenceException, since there are no live strong references to f. The only reliable information IsAlive can give you, is that the object is no longer alive since once it’s dead, it’s dead (even resurrecting the target won’t make IsAlive return true once it thinks the object is dead).

The correct pattern for the above code looks like this:

Foo f = new Foo();

WeakReference wr = new WeakReference(f);

// code goes here...

Foo f2 = (Foo)wr.Target; // new strong reference

if (f2!=null)

{

Console.WriteLine(f2.ToString());

}

So how is IsAlive useful at all? You could imagine implementing a cache by using a collection of WeakReferences, and using the IsAlive property to determine if an object still exists, and if not, replenish the cache. Just be careful to only make decisions based on IsAlive returning false.

Chris Lyon's WebLog : WeakReferences

WeakReferences And Tracking Resurrection

Why You Shouldn’t Rely On WeakReference.IsAlive