java什么是正确的Singleton实现，为什么

Question

两种java实现之间的区别是什么，哪一种是正确的，为什么

class Singleton
{
    private static Singleton instance = new Singleton();

    private Singleton()
    {
        System.out.println("Singleton(): Initializing Instance");
    }

    public static Singleton getInstance()
    {    
        return instance;
    }

}

或

class Singleton
{
    private static Singleton instance; 

    static
    {
        instance = new Singleton();
    }  

    private Singleton()
    {
        System.out.println("Singleton(): Initializing Instance");
    }

    public static Singleton getInstance()
    {    
        return instance;
    }


}

Answer 1

首先来问你的问题

好吧，两段代码都是一样的。我看不出有什么不同

然而，正如其他答案所暗示的，有更好的方法来创建单例实现。但这与你的问题有点离题，互联网（google）是你最好的朋友

Answer 2

这两种实现都不正确，而且静态限定符根本不是很好的实践：） 以下是我对单身人士的建议：

public final class LazySingleton {
    private static volatile LazySingleton instance = null;

    // private constructor
    private LazySingleton() {
    }

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

public class EagerSingleton {
    private static volatile EagerSingleton instance = null;

    // private constructor
    private EagerSingleton() {
    }

    public static EagerSingleton getInstance() {
        if (instance == null) {
            synchronized (EagerSingleton.class) {
                // Double check
                if (instance == null) {
                    instance = new EagerSingleton();
                }
            }
        }
        return instance;
    }
}

Answer 3

没什么区别。在这两种情况下，您都在急切地创建一个实例，在调用getInstance（）时，该实例已经准备就绪

但是如果你想要一个简单而好的单例实现

最好使用枚举来实现单例

public enum Singleton {
       INSTANCE;
   }

Answer 4

一般来说，Singleton设计模式的概念是基于只有一个instance的class。这可以通过两个主要方面来实现：

1）为类提供私有构造函数，以防止任何外部类调用它并重新创建实例。这可以通过以下方式实现：

private Singleton()
{
    System.out.println("Singleton(): Initializing Instance");
}

2）有一个static方法，允许您检索初始化的instance，或者在尚未初始化时初始化它，正如@awvery Awesome在他的回答中提到的：

public static Singleton newInstance()
{
if (singleton == null)
{
  singleton = new Singleton();
}

return singleton;
}

Answer 5

我的答案基于这篇关于单身的文章：http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

1. 您的第一个示例应该始终有效，但不允许lazy init
2. 在单线程环境中，可以实现“我的”第一个示例中的单线程
3. 在Java 1.5和引用的可变对象的多线程环境中，可以使用“我的”第二个示例
4. 有用的答案/文章：
   • What is an efficient way to implement a singleton pattern in Java?
   • Implementing the singleton pattern in Java
   • Singleton class in java

例1：

class SingleSingleton { 

    private Helper helper = null;

    public Helper getHelper() {
        if (helper == null) 
            helper = new Helper();
        return helper;
    }
}

例2：

class MultiSingletonJDK5 {
    private volatile Helper helper = null;

    public Helper getHelper() {
        if (helper == null) {
            synchronized(this) {
                if (helper == null)
                    helper = new Helper();
            }
        }
        return helper;
    }
}

我希望这有帮助。如果没有，请提供一些细节或更多背景信息

Answer 6

上述两种方法都不是应用单例模式的正确方法

这是正确的方法。惰性实例化方式：

public class Singleton
{
  private static Singleton singleton;

  private Singleton()
  {
  }

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

    return singleton;
  }
}

当第一次调用getInstance()对象时，Singleton方法会惰性地实例化它。因此Singleton对象在需要时才出现在内存中