免责声明：我刚刚总结了所有很棒的答案，并用我的话写下来。
在实施Singleton时，我们有2个选项
1.延迟加载
2.提前加载
延迟加载会增加一些开销（老实说，很多），因此仅当您有非常大的对象或繁重的构造代码并且还需要在需要实例之前使用其他可访问的静态方法或字段时才使用它您需要使用延迟初始化。否则，选择早期加载是一个不错的选择。
实现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;
}
}
这称为“双重检查锁定习惯用法”。容易忘记易失性陈述，也很难理解为什么这样做是必要的。
有关详细信息：http : //www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html
现在我们可以确定邪恶线程，但是残酷的序列化又如何呢？我们必须确保即使反序列化也不会创建新对象
class Foo implements Serializable {
private static final long serialVersionUID = 1L;
private static volatile Foo INSTANCE = null;
// 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();
}
而已！不再担心序列化，线程和丑陋的代码。此外枚举单被延迟初始化。
这种方法在功能上与公共领域方法等效，除了它更简洁，免费提供序列化机制，甚至针对复杂的序列化或反射攻击，还提供了针对多重实例化的明确保证。尽管此方法尚未广泛采用，但单元素枚举类型是实现单例的最佳方法。
-“有效Java”中的约书亚·布洛赫（Joshua Bloch）
现在您可能已经意识到为什么将ENUMS视为实现Singleton的最佳方法了，并感谢您的耐心：)
在我的博客上进行了更新。