Java版的7種單例模式寫法示例

更新時(shí)間：2019年10月01日 08:49:43 作者：振興

這篇文章主要給大家介紹了關(guān)于Java版的7種單例模式寫法，文中通過示例代碼介紹的非常詳細(xì)，對(duì)大家學(xué)習(xí)或者使用Java具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面來一起學(xué)習(xí)學(xué)習(xí)吧

前言

今天看到某一篇文章的一句話單例DCL 前面加 V 。就這句話讓我把單例模式又仔細(xì)看了一遍。

Java 中的單例模式是我們一直且經(jīng)常使用的設(shè)計(jì)模式之一，大家都很熟悉，所以這篇文章僅僅做我自己記憶。

單例模式（Singleton Pattern）是 Java 中最簡單的設(shè)計(jì)模式之一。這種類型的設(shè)計(jì)模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對(duì)象的最佳方式。

單例模式涉及到一個(gè)單一的類，該類負(fù)責(zé)創(chuàng)建自己的對(duì)象，同時(shí)確保只有單個(gè)對(duì)象被創(chuàng)建。這個(gè)類提供了一種訪問其唯一的對(duì)象的方式，可以直接訪問，不需要實(shí)例化該類的對(duì)象。

單例類只能有一個(gè)實(shí)例。
單例類必須自己創(chuàng)建自己的唯一實(shí)例。
單例類必須給所有其他對(duì)象提供這一實(shí)例。

Java版七種單例模式寫法

一：懶漢，線程不安全

這種寫法lazy loading很明顯，但是致命的是在多線程不能正常工作。

public class Singleton{
 private static Singleton instance;
 private Singleton(){};
 public static Singleton getInstance(){
 if (instance == null) {
  instance = new Singleton();
 }
 return instance;
 }
}

二：懶漢，線程安全

這種寫法能夠在多線程中很好的工作，而且看起來它也具備很好的lazy loading，但是，遺憾的是，效率很低，99%情況下不需要同步。

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

三：餓漢

這種方式基于classloder機(jī)制避免了多線程的同步問題，不過，instance在類裝載時(shí)就實(shí)例化，雖然導(dǎo)致類裝載的原因有很多種，在單例模式中大多數(shù)都是調(diào)用getInstance方法，但是也不能確定有其他的方式（或者其他的靜態(tài)方法）導(dǎo)致類裝載，這時(shí)候初始化instance顯然沒有達(dá)到lazy loading的效果。

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

四：餓漢，變種

表面上看起來差別挺大，其實(shí)更第三種方式差不多，都是在類初始化即實(shí)例化instance。

public class Singleton{
 private static Singleton instance = null;
 private Singleton(){};
 static {
  instance = new Singleton();
 }
 public static Singleton getInstance(){
  return instance;
 }
}

五：靜態(tài)內(nèi)部類

這種方式同樣利用了classloder的機(jī)制來保證初始化instance時(shí)只有一個(gè)線程，它跟第三種和第四種方式不同的是（很細(xì)微的差別）：第三種和第四種方式是只要Singleton類被裝載了，那么instance就會(huì)被實(shí)例化（沒有達(dá)到lazy loading效果），而這種方式是Singleton類被裝載了，instance不一定被初始化。因?yàn)镾ingletonHolder類沒有被主動(dòng)使用，只有顯示通過調(diào)用getInstance方法時(shí)，才會(huì)顯示裝載SingletonHolder類，從而實(shí)例化instance。想象一下，如果實(shí)例化instance很消耗資源，我想讓他延遲加載，另外一方面，我不希望在Singleton類加載時(shí)就實(shí)例化，因?yàn)槲也荒艽_保Singleton類還可能在其他的地方被主動(dòng)使用從而被加載，那么這個(gè)時(shí)候?qū)嵗痠nstance顯然是不合適的。這個(gè)時(shí)候，這種方式相比第三和第四種方式就顯得很合理。

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

似乎靜態(tài)內(nèi)部類看起來已經(jīng)是最完美的方法了，其實(shí)不是，可能還存在反射攻擊或者反序列化攻擊。且看如下代碼：

public static void main(String[] args) throws Exception {
 Singleton singleton = Singleton.getInstance();
 Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
 constructor.setAccessible(true);
 Singleton newSingleton = constructor.newInstance();
 System.out.println(singleton == newSingleton);
}

六：枚舉

這種方式是Effective Java作者Josh Bloch 提倡的方式，最佳的單例實(shí)現(xiàn)模式就是枚舉模式。利用枚舉的特性，讓JVM來幫我們保證線程安全和單一實(shí)例的問題，而且還能防止反序列化重新創(chuàng)建新的對(duì)象。除此之外，寫法還特別簡單。

public enum Singleton {
 INSTANCE;
 public void get() {
  System.out.println("");
 }
}

通過反編譯我們看到，枚舉是在 static 塊中進(jìn)行的對(duì)象的創(chuàng)建。

public final class com.loadclass.test.Singleton extends java.lang.Enum<com.loadclass.test.Singleton> {
 public static final com.loadclass.test.Singleton INSTANCE;

 public static com.loadclass.test.Singleton[] values();
 Code:
  0: getstatic  #1     // Field $VALUES:[Lcom/loadclass/test/Singleton;
  3: invokevirtual #2     // Method "[Lcom/loadclass/test/Singleton;".clone:()Ljava/lang/Object;
  6: checkcast  #3     // class "[Lcom/loadclass/test/Singleton;"
  9: areturn

 public static com.loadclass.test.Singleton valueOf(java.lang.String);
 Code:
  0: ldc   #4     // class com/loadclass/test/Singleton
  2: aload_0
  3: invokestatic #5     // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
  6: checkcast  #4     // class com/loadclass/test/Singleton
  9: areturn

 public void get();
 Code:
  0: getstatic  #7     // Field java/lang/System.out:Ljava/io/PrintStream;
  3: ldc   #8     // String
  5: invokevirtual #9     // Method java/io/PrintStream.println:(Ljava/lang/String;)V
  8: return

 static {};
 Code:
  0: new   #4     // class com/loadclass/test/Singleton
  3: dup
  4: ldc   #10     // String INSTANCE
  6: iconst_0
  7: invokespecial #11     // Method "<init>":(Ljava/lang/String;I)V
  10: putstatic  #12     // Field INSTANCE:Lcom/loadclass/test/Singleton;
  13: iconst_1
  14: anewarray  #4     // class com/loadclass/test/Singleton
  17: dup
  18: iconst_0
  19: getstatic  #12     // Field INSTANCE:Lcom/loadclass/test/Singleton;
  22: aastore
  23: putstatic  #1     // Field $VALUES:[Lcom/loadclass/test/Singleton;
  26: return
}

七：雙重校驗(yàn)鎖（ DCL：double-checked locking)

public class Singleton {
 // jdk1.6及之后，只要定義為private volatile static SingleTon instance 就可解決DCL失效問題。
 // volatile確保instance每次均在主內(nèi)存中讀取，這樣雖然會(huì)犧牲一點(diǎn)效率，但也無傷大雅。
 // volatile可以保證即使java虛擬機(jī)對(duì)代碼執(zhí)行了指令重排序，也會(huì)保證它的正確性。
 private volatile static Singleton singleton;
 private Singleton(){};
 public static Singleton getSingleton() {
  if (singleton == null) {
   synchronized (Singleton.class) {
    if (singleton == null) {
     singleton = new Singleton();
    }
   }
  }
  return singleton;
 }
}

DCL及解決辦法&說明：

針對(duì)延遲加載法的同步實(shí)現(xiàn)所產(chǎn)生的性能低的問題，可以采用DCL，即雙重檢查加鎖（Double Check Lock）的方法來避免每次調(diào)用getInstance()方法時(shí)都同步。

Double-Checked Locking看起來是非常完美的。但是很遺憾，根據(jù)Java的語言規(guī)范，上面的代碼是不可靠的。

出現(xiàn)上述問題, 最重要的2個(gè)原因如下:

編譯器優(yōu)化了程序指令, 以加快cpu處理速度.
多核cpu動(dòng)態(tài)調(diào)整指令順序, 以加快并行運(yùn)算能力.

問題出現(xiàn)的順序

線程A, 發(fā)現(xiàn)對(duì)象未實(shí)例化, 準(zhǔn)備開始實(shí)例化
由于編譯器優(yōu)化了程序指令, 允許對(duì)象在構(gòu)造函數(shù)未調(diào)用完前, 將共享變量的引用指向部分構(gòu)造的對(duì)象, 雖然對(duì)象未完全實(shí)例化, 但已經(jīng)不為null了.
線程B, 發(fā)現(xiàn)部分構(gòu)造的對(duì)象已不是null, 則直接返回了該對(duì)象.

解決辦法:

可以將instance聲明為volatile，即 private volatile static Singleton instance

在線程B讀一個(gè)volatile變量后，線程A在寫這個(gè)volatile變量之前，所有可見的共享變量的值都將立即變得對(duì)線程B可見。

總結(jié)：

如果單例由不同的類裝載器裝入，那便有可能存在多個(gè)單例類的實(shí)例。假定不是遠(yuǎn)端存取，例如一些servlet容器對(duì)每個(gè)servlet使用完全不同的類裝載器，這樣的話如果有兩個(gè)servlet訪問一個(gè)單例類，它們就都會(huì)有各自的實(shí)例。

private static Class getClass(String classname) throws ClassNotFoundException {
 ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
 if (classLoader == null) {
  classLoader = Singleton.class.getClassLoader();
 }
 return (classLoader.loadClass(classname));
}

如果Singleton實(shí)現(xiàn)了java.io.Serializable接口，那么這個(gè)類的實(shí)例就可能被序列化和復(fù)原。不管怎樣，如果你序列化一個(gè)單例類的對(duì)象，接下來復(fù)原多個(gè)那個(gè)對(duì)象，那你就會(huì)有多個(gè)單例類的實(shí)例。

public class Singleton implements Serializable {
 public static Singleton INSTANCE = new Singleton();
 private Singleton(){}
 //ObjectInputStream.readObject調(diào)用
 private Object readResolve() {
  return INSTANCE;
 }
}

總結(jié)

以上就是這篇文章的全部內(nèi)容了，希望本文的內(nèi)容對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，謝謝大家對(duì)腳本之家的支持。

您可能感興趣的文章: