Java中的简化单例模式

Question

实现单例模式的默认方式是：

class MyClass {
  private static MyClass instance;
  public static MyClass getInstance() {
    if (instance == null) {
      instance = new MyClass();
    }
    return instance;
  }
}

在一个旧项目中，我试图简化写作：

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

但它有时会失败。我只是不知道为什么，我做了默认的方式。 今天做一个SSCCE发到这里，我已经意识到代码可以工作了。

所以，我想知道意见.. 这是一个偶然的失败代码吗？ 第二种方法是否有可能返回null？ 我要疯了吗？

-- 虽然我不知道是否是每个案例的正确答案，但@Alfred 的答案非常有趣： 我还想指出，单身人士正在测试噩梦，根据大佬的说法，你应该使用谷歌的依赖注入框架。

Answer 1

推荐（Effective Java 2nd ed）的方式是做“枚举单例模式”：

enum MyClass {
    INSTANCE;

    // rest of singleton goes here
}

这里的关键见解是枚举值是单实例的，就像单例一样。所以，通过创建一个单值枚举，你只是让自己成为了一个单例。这种方法的美妙之处在于它是完全线程安全的，而且它还可以防止任何类型的允许人们创建其他实例的漏洞。

Answer 2

第一个解决方案（我相信）不是线程安全的。

第二个解决方案（我相信）是线程安全的，但如果您有复杂的初始化依赖关系，其中 MyClass.getInstance() 在 MyClass 静态初始化完成之前被调用，则可能无法工作。这可能就是您看到的问题。

这两种解决方案都允许某人创建您的（名义上的）单例类的另一个实例。

更强大的解决方案是：

class MyClass {

  private static MyClass instance;

  private MyClass() { }

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

在现代 JVM 中，只要不存在对锁的争用，获取锁的成本微乎其微。

编辑 @Nate 质疑我关于静态初始化顺序的陈述可能会导致问题。考虑以下（病态）示例：

public ClassA {
    public static ClassB myB = ClassB.getInstance();
    public static ClassA me = new ClassA();
    public static ClassA getInstance() {
        return me;
    }
}

public ClassB {
    public static ClassA myA = ClassA.getInstance();
    public static ClassB me = new ClassB();
    public static ClassB getInstance() {
        return me;
    }
}

这两个类有两种可能的初始化顺序。两者都会导致在执行方法的类静态初始化之前调用静态方法。这将导致ClassA.myB 或ClassB.myA 被初始化为null。

在实践中，静态变量之间的循环依赖没有这么明显。但事实仍然是，如果存在循环依赖：1) Java 编译器将无法告诉您它，2) JVM 不会告诉您它。相反，JVM 会默默地选择一个初始化顺序，而不会“理解”你正在尝试做的事情的语义......可能会导致一些意外/错误。

EDIT 2 - 在JLS 12.4.1 中描述如下：

如第 8.3.2.3 节中的示例所示，初始化代码不受限制的事实允许构造示例，其中当类变量的值仍具有初始默认值时，在其初始化表达式为评估，但这样的例子在实践中很少见。 （这样的例子也可以构造为实例变量初始化；参见第 12.5 节末尾的例子）。这些初始化器中提供了语言的全部功能；程序员必须小心谨慎。 ...

Answer 3

第二个例子更可取，因为第一个不是线程安全的（正如 cmets 中所指出的那样）。第一个示例使用了一种称为lazy instantiation（或延迟初始化）的技术，它确保除非实际需要，否则不会创建 Singleton 实例。由于 Java 处理类加载和静态实例变量初始化的方式，这在 Java 中并不是真正需要的。

Answer 4

我还想指出，singletons 正在测试噩梦，根据大佬的说法，您应该使用 google 的 dependency injection framework。

Answer 5

记住，你需要声明一个私有构造函数来保证单例属性。

第二种情况可能更简单

class MyClass {
  public static final MyClass instance = new MyClass();

  private MyClass() {
      super()
  }
}

`

Answer 6

正如其他人所指出的，第一个不是线程安全的。不要打扰它，因为第二个非常好，并且只有在引用 MyClass 时才会实例化对象。此外，它使参考最终更好地表达了意图。

只要确保声明

private static final MyClass INSTANCE = new MyClass();

是类中的第一个静态声明，以避免在初始化之前调用 getInstance() 或 INSTANCE 的风险。

Answer 7

不要忘记 SingletonHolder 模式。请参阅this SO 问题。

Answer 8

我不知道你的问题的答案，但这是我可以如何构建相同的东西。

class MyClass {
  private static MyClass instance;

  static {
    instance = new MyClass();
  }

  private MyClass() { }

  public static MyClass getInstance() {
    return instance;
  }
}