Java中的惰性线程安全单例实例化模式

Question

每个程序员都不容易理解惰性线程安全的单例实例，因此我想在我们的企业框架中创建一个可以完成此工作的类。

你怎么看待这件事？你看到不好的东西吗？在Apache Commons中有类似的东西吗？我怎样才能使它更好？

Supplier.java

public interface Supplier<T> {
    public T get();
}

LazyThreadSafeInstantiator.java

public class LazyThreadSafeInstantiator<T> implements Supplier<T> {
    private final Supplier<T> instanceSupplier;

    private volatile T obj;

    public LazyThreadSafeInstantiator(Supplier<T> instanceSupplier) {
        this.instanceSupplier = instanceSupplier;
    }

    @Override
    // http://en.wikipedia.org/wiki/Double-checked_locking
    public T get() {
        T result = obj;  // Wikipedia: Note the usage of the local variable result which seems unnecessary. For some versions of the Java VM, it will make the code 25% faster and for others, it won't hurt.
        if (result == null) {
            synchronized(this) {
                result = obj;
                if (result == null) {
                    result = instanceSupplier.get();
                    obj = result;
                }
            }
        }
        return result;
    }
}

用法示例：

public class Singleton1 {
    private static final Supplier<Singleton1> instanceHolder =
        new LazyThreadSafeInstantiator<Singleton1>(new Supplier<Singleton1>() {
            @Override
            public Singleton1 get() {
                return new Singleton1();
            }
        });

    public Singleton1 instance() {
        return instanceHolder.get();
    }

    private Singleton1() {
        System.out.println("Singleton1 instantiated");
    }
}

谢谢

Answer 1

惰性线程安全的单例实例对于每个编码器来说都不容易理解

不，实际上非常非常简单：

public class Singleton{
    private final static Singleton instance = new Singleton();
    private Singleton(){ ... }
    public static Singleton getInstance(){ return instance; }
}

更好的是，使其成为枚举：

public enum Singleton{
    INSTANCE;
    private Singleton(){ ... }
}

它是线程安全的，并且是惰性的（初始化发生在类加载时，并且Java不会加载类，直到它们被首次引用）。

事实是，您有99％的时间 根本不需要延迟加载 。在剩余的1％中，在0.9％中，上述内容完全是懒惰的。

您是否已经运行了探查器，并确定您的应用程序确实达到了真正需要首先进行延迟加载的0.01％？不这么认为。那么，您为什么要浪费时间炮制这些Rube
Goldbergesque令人讨厌的代码来解决一个不存在的问题？