两个单例实现同样多线程证明？

Question

在下面的代码 sn-ps 中有两个 Singleton 的实现。 它们都是在 Java 多线程环境中实现单例的正确方法吗？

如果是这样，那是否意味着第二种实现方式完全没用了，无论何时你想实现一个Singleton，就用枚举方式？

我最喜欢的写单例的方式：

public enum Singleton {
  INSTANCE();
}

另一种写单例的方式（显式同步）：

public class Singleton {

  private static Singleton instance = null;
  private Singleton() {}

  public static synchronized Singleton getInstance() {
    if (instanz == null) {
      instanz = new Singleton();
    }
    return instanz;
  }

Answer 1

一些程序员讨论如何创建单例的原因是他们希望支持惰性创建但担心后续调用访问器方法的性能。

所以你的类使用synchronized 实现了惰性创建方面，但后续调用可能会受到synchronized 的不必要开销的影响。为了克服这种假设的开销，发明了臭名昭著的双重检查锁定，这引发了更多关于这个实际上完全无关的“问题”的讨论：

如果你想将惰性创建与单例结合起来，你可以使用：

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

整个构造是惰性的，因为类初始化不会在第一个线程调用 getInstance() 之前发生，并且它是线程安全的，因为 JVM 保证类初始化本身是线程安全的。这是最有效的解决方案，因为后续调用只会读取 final 字段，而无需同步。

这正是使用时发生的情况

public enum Singleton {
  INSTANCE;
}

它使您免于声明 private 构造函数，因为编译器会为您这样做。该字段隐式为static final。一个区别是字段本身是公开的，不需要访问器方法。

另外，enums 本质上支持序列化。存储常量时，不会存储实例数据，只存储类型和常量名称。并且在反序列化时，将查找当前运行时实例。所以如果你需要序列化支持，enum 应该是首选，否则没有太大区别（使用enum 可以节省一些输入）。

但是

• 您的应用程序中多久需要一次单例？ （如果您说“经常”，您应该重新考虑您的软件设计）
• 单例的访问器方法的性能多久与您的应用程序相关？
• 单例实例创建的惰性有多重要？
• 如果您需要单例，您真正需要对单例属性进行“铁定”保证的频率是多少？即，如果有人设法使用肮脏的反射技巧创建了第二个实例，那么可能出现的问题就是他的问题，不是吗？

简单地说，单例设计模式似乎被严重高估了，关于如何有效实施它的讨论甚至更多……

Answer 2

你们两种方法看起来都不错。但是，对于创建 Singleton，我将建议以下方法，该方法是 100% 线程安全且没有同步问题，因为它利用了 Java 的类加载机制。

P.S.：感谢 @james 的触发器。

懒惰的单身人士：
像这个类 Provider 只会被加载一次，因此 Network 类的实例只会存在一个，并且没有两个线程可以在同一个 JVM 中创建 2 个实例，因为类不会被加载两次。

优点：

• 仅在需要时创建实例。
• 调用getInstance()时无需承担同步成本，当有getInstance()同步时会发生这种情况。

• 类中可以有其他静态方法，不需要创建实例就可以调用，只有在需要实例方法调用时才创建实例。这是惰性单例的一个很好的优势。

  public class Network {
  private Network(){
  
  }
  
  private static class Provider {
      static final Network INSTANCE = new Network();
  }
  
  public static Network getInstance() {
      return Provider.INSTANCE;
  }
  //More code...
  

  }

渴望单身：

private static Network INSTANCE = null;

private Network(){
}

static {
    INSTANCE = new Network();
}

public static Network getInstance() {
    return INSTANCE;
}

最后：你说得对，你指定的第二种方法确实是最后选择，因为它必须承担每次 2 个线程试图获取实例时的同步成本单身人士。

现在，它的 ENUM 单例与懒惰单例的博弈。我为您提供了一些关于为什么人们不喜欢 ENUM 作为单例的链接，以及 ENUM 单例与基于类加载的惰性单例的可伸缩性。

这两种方法都可以无缝地工作，所以它的选择问题，因此真正的答案是“这取决于！！！” :)

Answer 3

第一个解决方案适合您创建单例，因为您想对某事物的单个实例进行建模。在此解决方案中，如果在创建实例（如找不到文件）期间发生异常，您将获得 classnotfound 异常。

第二种解决方案适用于创建单例，因为创建对象需要很长时间，并且涉及对文件系统或网络的访问。

Answer 4

两者都是线程安全的，但第一个使用枚举可以避免不必要的锁定，并且在大多数情况下更可取。