有时简单的“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立即执行静态{}-块。这就是全部秘密：静态块只被调用一次，即这个单类加载器加载给定包的给定类（名称）的时间。

我仍然认为在Java1.5之后，enum是可用的最佳单例实现，因为它还确保了即使在多线程环境中，也只创建一个实例。

public enum Singleton {
    INSTANCE;
}

你完蛋了！

根据用法，有几个“正确”答案。

自Java5以来，最好的方法是使用枚举：

public enum Foo {
   INSTANCE;
}

在Java 5之前，最简单的情况是：

public final class Foo {

    private static final Foo INSTANCE = new Foo();

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

    public static Foo getInstance() {
        return INSTANCE;
    }

    public Object clone() throws CloneNotSupportedException{
        throw new CloneNotSupportedException("Cannot clone instance of this class");
    }
}

让我们复习一下代码。首先，你希望这门课是期末考试。在本例中，我使用了final关键字来让用户知道它是final。然后，需要将构造函数设为私有，以防止用户创建自己的Foo。从构造函数中抛出异常会阻止用户使用反射来创建第二个Foo。然后创建一个私有的静态final Foo字段来保存唯一的实例，并创建一个公共的静态Foo-getInstance（）方法来返回它。Java规范确保只有在首次使用类时才调用构造函数。

当您有一个非常大的对象或大量的构造代码，并且还有其他可访问的静态方法或字段，这些方法或字段可能在需要实例之前使用，那么只有在需要时才需要使用惰性初始化。

您可以使用私有静态类来加载实例。代码将如下所示：

public final class Foo {

    private static class FooLoader {
        private static final Foo INSTANCE = new Foo();
    }

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

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

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

当您还希望能够序列化对象时，需要确保反序列化不会创建副本。

public final class Foo implements Serializable {

    private static final long serialVersionUID = 1L;

    private static class FooLoader {
        private static final Foo INSTANCE = new Foo();
    }

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

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

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

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

看看这篇文章。

Java核心库中的GoF设计模式示例

从最佳答案的“Singleton”部分，

Singleton（可由每次返回相同实例（通常是其本身）的创建方法识别）java.lang.Runtime#获取运行时间（）java.awt.Desktop#getDesktop（）java.lang.System#getSecurityManager（）

您还可以从Java本机类本身学习Singleton的示例。

确保你真的需要它。在谷歌上搜索“singleton反模式”，看看反对它的一些论点。

我想这并没有什么本质上的问题，但它只是一种公开某些全局资源/数据的机制，因此请确保这是最好的方法。特别是，我发现依赖注入（DI）更有用，特别是如果您也在使用单元测试，因为DI允许您将模拟资源用于测试目的。

如果需要惰性地加载类的实例变量，则需要双重检查习惯用法。如果需要惰性地加载静态变量或单例，则需要按需初始化持有者习惯用法。

此外，如果单例需要可序列化，则所有其他字段都需要是暂时的，并且需要实现readResolve（）方法以保持单例对象不变。否则，每次反序列化对象时，都会创建对象的新实例。readResolve（）所做的是用readObject（）替换读取的新对象，因为没有变量引用该对象，所以强制对该新对象进行垃圾回收。

public static final INSTANCE == ....
private Object readResolve() {
  return INSTANCE; // Original singleton instance.
}