我见过的最好的单例模式使用Supplier接口。

它是通用的，可重复使用它支持延迟初始化它只有在初始化之前才同步，然后将阻塞供应商替换为非阻塞供应商。

见下文：

public class Singleton<T> implements Supplier<T> {

    private boolean initialized;
    private Supplier<T> singletonSupplier;

    public Singleton(T singletonValue) {
        this.singletonSupplier = () -> singletonValue;
    }

    public Singleton(Supplier<T> supplier) {
        this.singletonSupplier = () -> {
            // The initial supplier is temporary; it will be replaced after initialization
            synchronized (supplier) {
                if (!initialized) {
                    T singletonValue = supplier.get();
                    // Now that the singleton value has been initialized,
                    // replace the blocking supplier with a non-blocking supplier
                    singletonSupplier = () -> singletonValue;
                    initialized = true;
                }
                return singletonSupplier.get();
            }
        };
    }

    @Override
    public T get() {
        return singletonSupplier.get();
    }
}

免责声明：我刚刚总结了所有很棒的答案，并用自己的话写了出来。

---

在实施Singleton时，我们有两种选择：

延迟加载早期加载

延迟加载增加了位开销（老实说，很多），所以只有当您有非常大的对象或大量的构造代码，并且有其他可访问的静态方法或字段（可能在需要实例之前使用）时，才需要使用延迟初始化。否则，选择提前加载是一个不错的选择。

实现单例的最简单方法是：

public class Foo {

    // It will be our sole hero
    private static final Foo INSTANCE = new Foo();

    private Foo() {
        if (INSTANCE != null) {
            // SHOUT
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        return INSTANCE;
    }
}

一切都很好，除了它是一个早期加载的单例。让我们尝试延迟加载的单例

class Foo {

    // Our now_null_but_going_to_be sole hero
    private static Foo INSTANCE = null;

    private Foo() {
        if (INSTANCE != null) {
            // SHOUT
            throw new IllegalStateException("Already instantiated");
        }
    }

    public static Foo getInstance() {
        // Creating only  when required.
        if (INSTANCE == null) {
            INSTANCE = new Foo();
        }
        return INSTANCE;
    }
}

到目前为止还不错，但我们的英雄在与多个邪恶线程单独战斗时将无法生存，这些线程需要我们英雄的许多实例。因此，让我们保护它免受邪恶的多线程攻击：

class Foo {

    private static Foo INSTANCE = null;

    // TODO Add private shouting constructor

    public static Foo getInstance() {
        // No more tension of threads
        synchronized (Foo.class) {
            if (INSTANCE == null) {
                INSTANCE = new Foo();
            }
        }
        return INSTANCE;
    }
}

但这还不足以保护英雄，真的！！！这是我们能/应该做的最好的事情来帮助我们的英雄：

class Foo {

    // Pay attention to volatile
    private static volatile Foo INSTANCE = null;

    // TODO Add private shouting constructor

    public static Foo getInstance() {
        if (INSTANCE == null) { // Check 1
            synchronized (Foo.class) {
                if (INSTANCE == null) { // Check 2
                    INSTANCE = new Foo();
                }
            }
        }
        return INSTANCE;
    }
}

这被称为“双重检查锁定习惯用法”。人们很容易忘记不稳定的说法，也很难理解为什么有必要这样做。详细信息：“双重检查锁定失败”声明

现在我们确定了邪恶的线索，但残酷的连载呢？我们必须确保即使在反序列化时也不会创建新对象：

class Foo implements Serializable {

    private static final long serialVersionUID = 1L;

    private static volatile Foo INSTANCE = null;

    // The rest of the things are same as above

    // No more fear of serialization
    @SuppressWarnings("unused")
    private Object readResolve() {
        return INSTANCE;
    }
}

方法readResolve（）将确保返回唯一的实例，即使对象在我们的程序的上一次运行中被序列化。

最后，我们添加了足够的线程和序列化保护，但我们的代码看起来又大又难看。让我们给我们的英雄一个新形象：

public final class Foo implements Serializable {

    private static final long serialVersionUID = 1L;

    // Wrapped in a inner static class so that loaded only when required
    private static class FooLoader {

        // And no more fear of threads
        private static final Foo INSTANCE = new Foo();
    }

    // TODO add private shouting construcor

    public static Foo getInstance() {
        return FooLoader.INSTANCE;
    }

    // Damn you serialization
    @SuppressWarnings("unused")
    private Foo readResolve() {
        return FooLoader.INSTANCE;
    }
}

是的，这是我们的英雄：）

由于行private static final Foo INSTANCE=new Foo（）；仅在实际使用FooLoader类时执行，这会处理延迟实例化，并保证线程安全。

我们已经走到了今天。以下是实现我们所做一切的最佳方式：

public enum Foo {
    INSTANCE;
}

内部将被视为

public class Foo {

    // It will be our sole hero
    private static final Foo INSTANCE = new Foo();
}

就是这样！不再担心序列化、线程和丑陋的代码。ENUMS单例也被延迟初始化。

该方法在功能上等同于公共领域方法，除了它更简洁，提供了序列化机制免费提供，并提供多重保险实例化，即使面对复杂的序列化或反射攻击。虽然这种方法尚未被广泛采用，单个元素枚举类型是实现单例的最佳方式。

-《有效的Java》中的约书亚·布洛赫

现在您可能已经意识到为什么ENUMS被认为是实现单例的最佳方式，并感谢您的耐心：）

在我的博客上更新了它。

有时简单的“static Foo=new Foo（）；”是不够的。想想你想做的一些基本数据插入。

另一方面，您必须同步任何实例化单例变量的方法。同步本身并不坏，但它可能会导致性能问题或锁定（在非常罕见的情况下，使用本示例。解决方案是

public class Singleton {

    private static Singleton instance = null;

    static {
          instance = new Singleton();
          // do some of your instantiation stuff here
    }

    private Singleton() {
          if(instance!=null) {
                  throw new ErrorYouWant("Singleton double-instantiation, should never happen!");
          }
    }

    public static getSingleton() {
          return instance;
    }

}

现在会发生什么？类通过类加载器加载。在从字节数组解释类之后，VM立即执行静态{}-块。这就是全部秘密：静态块只被调用一次，即这个单类加载器加载给定包的给定类（名称）的时间。

如果您不需要延迟加载，那么只需尝试：

public class Singleton {
    private final static Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() { return Singleton.INSTANCE; }

    protected Object clone() {
        throw new CloneNotSupportedException();
    }
}

如果您希望延迟加载并且希望单例是线程安全的，请尝试双重检查模式：

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {}

    public static Singleton getInstance() {
        if(null == instance) {
            synchronized(Singleton.class) {
                if(null == instance) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    protected Object clone() {
        throw new CloneNotSupportedException();
    }
}

由于双重检查模式不能保证有效（由于编译器的一些问题，我对此一无所知），因此您也可以尝试同步整个getInstance方法或为所有单例创建注册表。

维基百科有一些单态的例子，也在Java中。Java5实现看起来非常完整，并且是线程安全的（应用了双重检查锁定）。

public class Singleton {

    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {
        if (INSTANCE != null)
            throw new IllegalStateException(“Already instantiated...”);
        }


    public synchronized static Singleton getInstance() {
        return INSTANCE;
    }

}

由于我们在getInstance之前添加了Synchronized关键字，因此在两个线程同时调用getInstance的情况下，我们避免了竞争条件。