Another DCL-like approach, correct or broken?

Hi,

Below is my small utility class supporting creation of the singleton in
lazy fashion (the usage is close to of the ThreadLocal). In the
nutshell the approach is similar to the well known DCL idiom fixed Java
5+ implementation (see:
http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html).
  But in addition to the volatile field, and monitor based
synchronization (the latter at creation time, and possibly at first
access only), it guards lazy initialization of the value on final field
rules (JLS3 17.5), which all seems to prevent from uninitialized value
access in case of the reorderings.

Do you think is this approach correct, or broken in the sense of
thread-safety and the Java memory model semantics?

Is a volatile field still really needed here?

Thanks.

public abstract class SingletonReference {

     private static abstract class ValueRef {
         abstract Object get();
     }

     volatile ValueRef valueRef = new ValueRef() {

         synchronized final Object get() {
             ValueRef ref = valueRef;
             if (ref == this) {
                 ref = valueRef = new FixedValueRef(initialValue());
             }
             return ref.get();
         }
     };

     private static final class FixedValueRef extends ValueRef {
         private final Object value;

         FixedValueRef(Object value) {
             this.value = value;
         }

         final Object get() {
             return value;
         }
     }

     protected abstract Object initialValue();

     public final Object get() {
         return valueRef.get();
     }
}

piotr