延遲加載和線程安全相結合的單例模式

Question

我正在做一些關於單例的研究，特別是關於單例的懶惰和渴望的初始化。

渴望初始化的例子：

public class Singleton 
{ 
    //initialzed during class loading 
    private static final Singleton INSTANCE = new Singleton(); 

    //to prevent creating another instance of Singleton 
    private Singleton(){} 

    public static Singleton getSingleton(){ 
     return INSTANCE; 
    } 
} 

但高於它是渴望初始化和線程安全留給JVM 但現在，我希望能有同樣的模式，但與延遲初始化，如圖所示。

所以我想出這種方法：

public final class Foo { 
    private static class FooLoader { 
     private static final Foo INSTANCE = new Foo(); 
    } 
    private Foo() { 
     if (FooLoader.INSTANCE != null) { 
      throw new IllegalStateException("Already instantiated"); 
     } 
    } 
    public static Foo getInstance() { 
     return FooLoader.INSTANCE; 
    } 
} 

如上所示由於線

private static final Foo INSTANCE = new Foo(); 

當類FooLoader實際使用時才執行，這需要照顧的延遲實例的，並且它保證是線程安全的。

這是正確的嗎？

Answer 1

在我看來，你的第二個代碼片段是線程安全懶惰初始化單例的最好方法。它實際上有一個模式名稱

Initialization-on-demand holder idiom

我會建議你使用它。

Answer 2

最好的辦法實際上是使用Enum Way：

public enum Singleton { 
    INSTANCE; 
    public void execute (String arg) { 
      //... perform operation here ... 
    } 
} 

Answer 3

第二個是在可讀性方面非常糟糕，第一個是合適的。看看這個article。它關於雙重檢查鎖定，但也會給你關於單身多線程的廣泛信息。

Answer 4

你的第一個設計實際上是懶惰的。想想看，這個實例只是在類被初始化時才創建的;該類只在調用getSingleton()方法時初始化[1]。所以這個實例只有在被要求的時候纔會被創建，也就是說它被延遲創建。

[1] http://docs.oracle.com/javase/specs/jls/se7/html/jls-12.html#jls-12.4.1

Answer 5

在我看來，這是使用不恰當的模式。它對JVM的行爲進行了假設，這些行爲是不平凡的和令人困惑的。另外，它有一個虛擬類。儘可能避免假類。

我建議直接的方法：

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

    private Foo() { 
    } 

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

...雖然，這是行不通的 - 是 - 它不是線程安全的..你真正想要的是在第71條提出的雙重檢查圖案Bloch's Effective Java;見here。修改實例在鏈接到你的情況，我們得到：

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

    private Foo() { 
    } 

    public static Foo instance() { 
     if (instance != null) return instance; 
     synchronized(instance) { 
      Foo result = instance; 
      if (instance == null) { 
       result = instance = new Foo(); 
      return result; 
     } 
    } 
} 

注：

• 不要擔心這個代碼的性能，現代JVM照顧它，它就好了。畢竟，premature optimization is the root of all evil。
• 正如其他答案中的建議，上述不是布洛赫的首選解決方案，但我認爲使用一個單例的枚舉在語義上是不恰當的，就像OP最初所做的一樣。