另一个经常用来反对单态的论点是它们的可测试性问题。出于测试目的，单体不容易被模拟。如果这是一个问题，我想做以下轻微修改：

public class SingletonImpl {

    private static SingletonImpl instance;

    public static SingletonImpl getInstance() {
        if (instance == null) {
            instance = new SingletonImpl();
        }
        return instance;
    }

    public static void setInstance(SingletonImpl impl) {
        instance = impl;
    }

    public void a() {
        System.out.println("Default Method");
    }
}

添加的setInstance方法允许在测试期间设置单例类的实体模型实现：

public class SingletonMock extends SingletonImpl {

    @Override
    public void a() {
        System.out.println("Mock Method");
    }

}

这也适用于早期初始化方法：

public class SingletonImpl {

    private static final SingletonImpl instance = new SingletonImpl();

    private static SingletonImpl alt;

    public static void setInstance(SingletonImpl inst) {
        alt = inst;
    }

    public static SingletonImpl getInstance() {
        if (alt != null) {
            return alt;
        }
        return instance;
    }

    public void a() {
        System.out.println("Default Method");
    }
}

public class SingletonMock extends SingletonImpl {

    @Override
    public void a() {
        System.out.println("Mock Method");
    }

}

这有一个缺点，就是将此功能也暴露给普通应用程序。其他编写该代码的开发人员可能会尝试使用“setInstance”方法来更改特定函数，从而改变整个应用程序的行为，因此该方法的javadoc中至少应该包含一个良好的警告。

尽管如此，对于模型测试的可能性（当需要时），这种代码暴露可能是可以接受的代价。

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

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

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

我可以说是枚举单例。

在Java中使用枚举通常是声明枚举单例的一种方法。枚举单例可以包含实例变量和实例方法。为了简单起见，还要注意，如果您正在使用任何实例方法，那么如果该方法影响对象的状态，则需要确保该方法的线程安全。

枚举的使用非常容易实现，并且在可序列化对象方面没有缺点，必须通过其他方式规避这些缺点。

/**
* Singleton pattern example using a Java Enum
*/
public enum Singleton {
    INSTANCE;
    public void execute (String arg) {
        // Perform operation here
    }
}

您可以通过Singleton.INSTANCE访问它，它比在Singleton上调用getInstance（）方法简单得多。

1.12枚举常量的序列化枚举常量的序列化方式不同于普通的可序列化或可外部化对象。枚举常量的序列化形式仅由其名称组成；表单中不存在常量的字段值。若要序列化枚举常量，ObjectOutputStream将写入枚举常量的name方法返回的值。要反序列化枚举常量，ObjectInputStream从流中读取常量名称；然后通过调用java.lang.Enum.valueOf方法获得反序列化的常量，并将常量的枚举类型与接收到的常量名称作为参数一起传递。与其他可序列化或可外部化对象一样，枚举常量可以用作后续在序列化流中出现的反向引用的目标。无法自定义枚举常量的序列化过程：在序列化和反序列化期间，将忽略枚举类型定义的任何类特定的writeObject、readObject、readObjectNoData、writeReplace和readResolve方法。类似地，任何serialPersistentFields或serialVersionUID字段声明也会被忽略——所有枚举类型都具有固定的serialVersionID 0L。记录枚举类型的可序列化字段和数据是不必要的，因为发送的数据类型没有变化。引自Oracle文档

传统singleton的另一个问题是，一旦实现了Serializable接口，它们就不再是单一的，因为readObject（）方法总是返回一个新的实例，就像Java中的构造函数一样。这可以通过使用readResolve（）并丢弃新创建的实例来避免，方法是将其替换为单例，如下所示：

 // readResolve to prevent another instance of Singleton
 private Object readResolve(){
     return INSTANCE;
 }

如果您的单例类保持状态，这可能会变得更加复杂，因为您需要使它们成为瞬态的，但是在枚举单例中，JVM保证了序列化。

好的阅读

Singleton模式枚举、Singleton和反序列化双重检查锁定和Singleton模式

枚举单例

实现线程安全的单例的最简单方法是使用Enum：

public enum SingletonEnum {
  INSTANCE;
  public void doSomething(){
    System.out.println("This is a singleton");
  }
}

自从在Java 1.5中引入Enum以来，此代码一直有效

双重检查锁定

如果你想编写一个在多线程环境中工作的“经典”单例（从Java1.5开始），你应该使用这个。

public class Singleton {

  private static volatile Singleton instance = null;

  private Singleton() {
  }

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

这在1.5之前不是线程安全的，因为volatile关键字的实现不同。

早期加载单例（甚至在Java1.5之前就可以使用）

这个实现在加载类时实例化单例，并提供线程安全性。

public class Singleton {

  private static final Singleton instance = new Singleton();

  private Singleton() {
  }

  public static Singleton getInstance() {
    return instance;
  }

  public void doSomething(){
    System.out.println("This is a singleton");
  }

}

看看这篇文章。

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

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

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

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

Stu Thompson发布的解决方案在Java 5.0及更高版本中有效。但我宁愿不使用它，因为我认为它容易出错。

人们很容易忘记不稳定的说法，也很难理解为什么有必要这样做。如果没有易失性，由于双重检查锁定反模式，该代码将不再是线程安全的。有关这一点的更多信息，请参阅《Java并发实践》第16.2.4段。简而言之：此模式（在Java5.0之前或没有volatile语句）可能返回对Bar对象的引用，该对象（仍然）处于错误状态。

这种模式是为性能优化而发明的。但这真的不再是一个真正的问题了。下面的惰性初始化代码很快，更重要的是，更容易阅读。

class Bar {
    private static class BarHolder {
        public static Bar bar = new Bar();
    }

    public static Bar getBar() {
        return BarHolder.bar;
    }
}