On Double Checked Locking in Java

You have probably all heard/seen the “Double-Checked Locking is Broken” declaration. And if you haven't I'll just tell you that before the improved memory model of Java 5, double checked locking didn't work as expected. Even in Java 5 and later there are things you need to consider to get it to work properly, and even more things to consider if you want it to perform well.

Joshua Bloch suggests in his book Effective Java, and keeps repeating in several presentations that there is one way to implement double checked locking and that this code snippet should be copied to every place where it's needed. I disagree. Not with the part about there only being one way of doing it, but with the copying part. In my eyes this is perfect use case for an abstract class:

package java.util.concurrent;

public abstract class LazyLoaded<T> {
    private volatile T value;
    // Get the value, guard the loading by double checked locking
    public final T getValue() {
        T result = value;
        if (result == null)   { // First check
            synchronized (this) { // Lock
                result = value;
                if (result == null) { // Second check
                    result = loadValue();
                    value = result;
                }
            }
        }
        return result;
    }
    protected abstract T loadValue();
}

This class would then be used like this:

package org.thobe.example;

import java.util.concurrent.LazyLoaded;

class UsesDoubleCheckedLocking {
    // The generics even makes it read well:
    private final LazyLoaded<Something>() {
        @Override protected Something loadValue() {
            return new Something();
        }
    };
    // ... your code will probably do something useful here ...
}

Just expressing my opinion. I hope someone important reads this and makes sure that it gets included in Java7. And while you're at it, make sure we get some standardized ways of composing Iterable/Iterators as well...