我最近在接受以下代码的采访时被问及与 Java 相关的问题，因为我对 Java 很陌生，几乎不会用 Java 编写代码，所以我真的不知道以下代码的作用。

问题是 使用以下代码选择描述最坏情况的选项:

public class Bolton { 
    private static Bolton INST = null; 
 
    public static Bolton getInstance() 
    { 
        if ( INST == null ) 
        { 
            INST = new Bolton(); 
        } 
        return INST; 
    } 
 
    private Bolton() { 
    } 
} 

这是这道题的选项

1. More than one instance of Bolton can be created
2. A Bolton will never be created
3. The constructor is private and can't be called
4. Value can be garbage collected, and the call to getInstance may return garbage data

以上哪个选项是正确的？为什么？

请您参考如下方法:

这是一个 Singleton Pattern

单例模式的思想是只有一个类的可用实例。因此 constructor 被设置为 private 并且类维护，在这种情况下，调用现有实例变量的 getInstance() 方法， INST 在这个类中，或者为正在执行的程序创建一个新的。答案可能是 1，因为它不是线程安全的。它可能与我之前记下的 3 混淆了，但从技术上讲，这是设计使然，所以实际上并不是缺陷。

这是来自维基百科的惰性初始化、线程安全单例模式的示例:

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

将实例变量设置为 volatile告诉 Java 从内存中读取它，而不是将其设置在缓存中。

Synchronized statements or methods帮助 concurrency .

阅读更多关于 double checked locking 的信息这就是“惰性初始化”单例发生的情况