java設計模式中如何實現單例模式

這篇文章將為大家詳細講解有關java設計模式中如何實現單例模式，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

下面是一個簡單的小實例：

//簡單懶漢式 
public class Singleton { 
   
  //單例實例變量 
  private static Singleton instance = null; 
   
  //私有化的構造方法，保證外部的類不能通過構造器來實例化 
  private Singleton() {} 
   
  //獲取單例對象實例 
  public static Singleton getInstance() { 
     
    if (instance == null) {  
      instance = new Singleton();  
    } 
     
    System.out.println("我是簡單懶漢式單例！"); 
    return instance; 
  } 
}

很容易看出，上面這段代碼在多線程的情況下是不安全的，當兩個線程進入if (instance == null)時，兩個線程都判斷instance為空，接下來就會得到兩個實例了。這不是我們想要的單例。

接下來我們用加鎖的方式來實現互斥，從而保證單例的實現。

//同步法懶漢式 
public class Singleton { 
   
  //單例實例變量 
  private static Singleton instance = null; 
   
  //私有化的構造方法，保證外部的類不能通過構造器來實例化 
  private Singleton() {} 
   
  //獲取單例對象實例 
  public static synchronized Singleton getInstance() { 
     
    if (instance == null) {  
      instance = new Singleton();  
    } 
     
    System.out.println("我是同步法懶漢式單例！"); 
    return instance; 
  } 
}

加上synchronized后確實保證了線程安全，但是這樣就是最好的方法嗎？很顯然它不是，因為這樣一來每次調用getInstance()方法是都會被加鎖，而我們只需要在第一次調用getInstance()的時候加鎖就可以了。這顯然影響了我們程序的性能。我們繼續尋找更好的方法。

經過分析發現，只需要保證instance = new Singleton()是線程互斥就可以保證線程安全，所以就有了下面這個版本：

//雙重鎖定懶漢式 
public class Singleton { 
   
  //單例實例變量 
  private static Singleton instance = null; 
   
  //私有化的構造方法，保證外部的類不能通過構造器來實例化 
  private Singleton() {} 
   
  //獲取單例對象實例 
  public static Singleton getInstance() { 
    if (instance == null) {  
      synchronized (Singleton.class) { 
        if (instance == null) {  
          instance = new Singleton();  
        } 
      } 
    } 
    System.out.println("我是雙重鎖定懶漢式單例！"); 
    return instance; 
  } 
}

這次看起來既解決了線程安全問題，又不至于每次調用getInstance()都會加鎖導致降低性能。看起來是一個完美的解決方案，事實上是這樣的嗎？

很遺憾，事實并非我們想的那么完美。java平臺內存模型中有一個叫“無序寫”（out-of-order writes）的機制。正是這個機制導致了雙重檢查加鎖方法的失效。這個問題的關鍵在上面代碼上的第5行：instance = new Singleton(); 這行其實做了兩個事情：1、調用構造方法，創建了一個實例。2、把這個實例賦值給instance這個實例變量。可問題就是，這兩步jvm是不保證順序的。也就是說。可能在調用構造方法之前，instance已經被設置為非空了。下面我們一起來分析一下：

假設有兩個線程A、B

1、線程A進入getInstance()方法。
2、因為此時instance為空，所以線程A進入synchronized塊。
3、線程A執行 instance = new Singleton(); 把實例變量instance設置成了非空。（注意，是在調用構造方法之前。）
4、線程A退出，線程B進入。
5、線程B檢查instance是否為空，此時不為空（第三步的時候被線程A設置成了非空）。線程B返回instance的引用。（問題出現了，這時instance的引用并不是Singleton的實例，因為沒有調用構造方法。）
6、線程B退出，線程A進入。
7、線程A繼續調用構造方法，完成instance的初始化，再返回。

難道就沒有一個好方法了嗎？好的方法肯定是有的，我們繼續探索！

//解決無序寫問題懶漢式 
public class Singleton { 
   
  //單例實例變量 
  private static Singleton instance = null; 
   
  //私有化的構造方法，保證外部的類不能通過構造器來實例化 
  private Singleton() {} 
   
  //獲取單例對象實例 
  public static Singleton getInstance() { 
    if (instance == null) {  
      synchronized (Singleton.class) {         //1 
        Singleton temp = instance;        //2 
        if (temp == null) { 
          synchronized (Singleton.class) { //3  
            temp = new Singleton();  //4   
          } 
          instance = temp;         //5    
        } 
      } 
    } 
    System.out.println("我是解決無序寫懶漢式單例！"); 
    return instance; 
  }   
}

1、線程A進入getInstance()方法。
2、因為instance是空的 ，所以線程A進入位置//1的第一個synchronized塊。
3、線程A執行位置//2的代碼，把instance賦值給本地變量temp。instance為空，所以temp也為空。
4、因為temp為空，所以線程A進入位置//3的第二個synchronized塊。（后來想想這個鎖有點多余）
5、線程A執行位置//4的代碼，把temp設置成非空，但還沒有調用構造方法！（“無序寫”問題）
6、如果線程A阻塞，線程B進入getInstance()方法。
7、因為instance為空，所以線程B試圖進入第一個synchronized塊。但由于線程A已經在里面了。所以無法進入。線程B阻塞。
8、線程A激活，繼續執行位置//4的代碼。調用構造方法。生成實例。
9、將temp的實例引用賦值給instance。退出兩個synchronized塊。返回實例。
10、線程B激活，進入第一個synchronized塊。
11、線程B執行位置//2的代碼，把instance實例賦值給temp本地變量。
12、線程B判斷本地變量temp不為空，所以跳過if塊。返回instance實例。

到此為止，上面的問題我們是解決了，但是我們突然發現為了解決線程安全問題，但給人的感覺就像身上纏了很多毛線.... 亂糟糟的，所以我們要精簡一下：

//餓漢式 
public class Singleton { 
   
  //單例變量 ,static的，在類加載時進行初始化一次，保證線程安全  
  private static Singleton instance = new Singleton();   
   
  //私有化的構造方法，保證外部的類不能通過構造器來實例化。    
  private Singleton() {} 
   
  //獲取單例對象實例    
  public static Singleton getInstance() { 
    System.out.println("我是餓漢式單例！"); 
    return instance; 
  } 
}

看到上面的代碼，瞬間覺得這個世界清靜了。不過這種方式采用的是餓漢式的方法，就是預先聲明Singleton對象，這樣帶來的一個缺點就是：如果構造的單例很大，構造完又遲遲不使用，會導致資源浪費。

到底有沒有完美的方法呢？繼續看：

//內部類實現懶漢式 
public class Singleton { 
   
  private static class SingletonHolder{ 
    //單例變量  
    private static Singleton instance = new Singleton(); 
  } 
   
  //私有化的構造方法，保證外部的類不能通過構造器來實例化。 
  private Singleton() { 
     
  } 
   
  //獲取單例對象實例 
  public static Singleton getInstance() { 
    System.out.println("我是內部類單例！"); 
    return SingletonHolder.instance; 
  } 
}

懶漢式（避免上面的資源浪費）、線程安全、代碼簡單。因為java機制規定，內部類SingletonHolder只有在getInstance()方法第一次調用的時候才會被加載（實現了lazy），而且其加載過程是線程安全的（實現線程安全）。內部類加載的時候實例化一次instance。

簡單說一下上面提到的無序寫，這是jvm的特性，比如聲明兩個變量，String a; String b; jvm可能先加載a也可能先加載b。同理，instance = new Singleton();可能在調用Singleton的構造函數之前就把instance置成了非空。這是很多人會有疑問，說還沒有實例化出Singleton的一個對象，那么instance怎么就變成非空了呢？它的值現在是什么呢？想了解這個問題就要明白instance = new Singleton();這句話是怎么執行的，下面用一段偽代碼向大家解釋一下：

mem = allocate();       //為Singleton對象分配內存。 
instance = mem;        //注意現在instance是非空的，但是還沒有被初始化。 
 
ctorSingleton(instance);  //調用Singleton的構造函數，傳遞instance.

由此可見當一個線程執行到instance = mem; 時instance已為非空，如果此時另一個線程進入程序判斷instance為非空，那么直接就跳轉到return instance;而此時Singleton的構造方法還未調用instance，現在的值為allocate();返回的內存對象。所以第二個線程得到的不是Singleton的一個對象，而是一個內存對象。

關于“java設計模式中如何實現單例模式”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。