java中全面的單例模式多種實現方式總結

單例模式的思想

想整理一些 java 併發相關的知識，不知道從哪開始，想起了單例模式中要考慮的線程安全，就從單例模式開始吧。
之前寫過單例模式，這裏再從新彙總補充整理一下，單例模式的多種實現。

單例模式那件小事，看了你不會後悔
單例模式不是一件小事，快回來看看

以前在第一篇文章說，單例模式的主要思想是：

• 將構造方法私有化（ 聲明爲 private ），這樣外界不能隨意 new 出新的實例對象；
• 聲明一個私有的靜態的實例對象，供外界使用；
• 提供一個公開的方法，讓外界得到該類的實例對象

這種說法看上去沒錯，但也好像不太準確。其實，就算外界能隨意 new 出新的實例對象，但只要咱們保證咱們每次使用的對象是惟一的，就能夠。

單例模式的 N 種實現方式

餓漢式（線程安全，可用）

public class Singleton {
    private Singleton() {
    }

    private static Singleton sSingleton = new Singleton();

    public static Singleton getInstance() {
        return sSingleton;
    }
}

• 缺點： 類一加載的時候，就實例化，提早佔用了系統資源。

常量式（線程安全，可用）

public class Singleton {
    private Singleton() {
    }

    public static final Singleton sSingleton = new Singleton();
}

將實例對象用 public static final 修飾，不提供公開方法獲取實例，直接經過 Singleton.sSingleton 獲取。

• 缺點：與餓漢式同樣，類一加載的時候，就實例化，提早佔用了系統資源。

懶漢式（線程不安全，併發場景不可用）

public class Singleton {
    private Singleton() {
    }

    private static Singleton sSingleton;

    public static Singleton getInstance() {
        if (sSingleton == null) {
            sSingleton = new Singleton();
        }
        return sSingleton;
    }
}

• 缺點：第一次第一次加載時反應稍慢，線程不安全。

同步的懶漢式？（線程安全，可用，不建議使用）

public class Singleton {
    private Singleton() {
    }

    private static Singleton sSingleton;

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

• 缺點：第一次加載時反應稍慢，每次調用 getInstance 都進行同步，形成沒必要要的同步開銷，這種模式通常不建議使用。

雙重檢查鎖 DCL (線程安全，大多數場景知足需求，推薦使用)

public class Singleton {
    private Singleton() {
    }

    /**
     * volatile is since JDK5
     */
    private static volatile Singleton sSingleton;

    public static Singleton getInstance() {
        if (sSingleton == null) {
            synchronized (Singleton.class) {
                // 未初始化，則初始instance變量
                if (sSingleton == null) {
                    sSingleton = new Singleton();
                }
            }
        }
        return sSingleton;
    }
}

sSingleton = new Singleton() 不是一個原子操做。（XXX）故須加 volatile 關鍵字修飾，該關鍵字在 jdk1.5 以後版本纔有。

• 優勢：資源利用率高，第一次執行getInstance時單例對象纔會被實例化，效率高。
• 缺點：第一次加載時反應稍慢，也因爲Java內存模型的緣由偶爾會失敗。在高併發環境下也有必定的缺陷，雖然發生的機率很小。DCL模式是使用最多的單例實現方式，它可以在須要時才實例化單例對象，而且可以在絕大多數場景下保證單例對象的惟一性，除非你的代碼在併發場景比較複雜或者低於jdk1.6版本下使用，不然這種方式通常可以知足需求。

靜態內部類（線程安全，推薦使用）

public class Singleton {

    private Singleton () {
    }

    private static class InnerClassSingleton {
　　　　 private final static Singleton sSingleton = new Singleton();
    }

    public static Singleton getInstance() {
        return InnerClassSingleton.sSingleton;
    }
}

優勢：推薦使用。

枚舉單例（線程安全，不建議使用）

public enum Singleton{
    INSTANCE;
    
    // 其它方法
    public void doSomething(){
        ...
    }
}

• 優勢：枚舉實現單例很簡單，也很安全。
• 缺點：經驗豐富的 Android 開發人員都會盡可能避免使用枚舉。官方文檔有說明：相比於靜態常量Enum會花費兩倍以上的內存。

另類實現——利用容器實現單例

import java.util.HashMap;
import java.util.Map;

public class Singleton {
    private static Map<String, Object> objMap = new HashMap<String, Object>();

    private Singleton() {
    }

    public static void registerService(String key, Object instance) {
        if (!objMap.containsKey(key)) {
            objMap.put(key, instance);
        }
    }

    public static Object getService(String key) {
        return objMap.get(key);
    }
}

利用了 HashMap 容器 key 不可重複的特性。

• 優勢：這種實現方式使得咱們能夠管理多種類型的單例，而且在使用時能夠經過統一接口進行獲取操做，下降用戶使用成本，也對用戶隱藏了具體實現，下降耦合度。
• 缺點：沒有私有化構造方法，用戶能夠 new 出新的實例對象。

防止反射破壞單例

前面的多種實現方法中，不少咱們按照構造方法私有化的思想來實現的，咱們知道，利用反射，仍然能夠建立出新對象，這樣在反射場景中，這種思想實現的單例模式就失效了，那麼如何防止反射破壞單例模式呢？原理上就是在存在一個實例的狀況下，再次調用構造方法時，拋出異常。下面以靜態內部類的單例模式爲例：

public class Singleton {
    private static boolean flag = false;  
  
    private Singleton(){  
        synchronized(Singleton.class)  
        {  
            if(flag == false)  
            {  
                flag = !flag;  
            }  
            else  
            {  
                throw new RuntimeException("單例模式被侵犯！");  
            }  
        }  
    }  

    private static class InnerClassSingleton {
　　　　 private final static Singleton sSingleton = new Singleton();
    }

    public static Singleton getInstance() {
        return InnerClassSingleton.sSingleton;
    }
}

具體測試代碼，見 單例模式不是一件小事，快回來看看

防止序列化和反序列化破壞單例

經過序列化能夠講一個對象實例寫入到磁盤中，經過反序列化再讀取回來的時候，即使構造方法是私有的，也依然能夠經過特殊的途徑，建立出一個新的實例，至關於調用了該類的構造函數。要避免這個問題，咱們須要在代碼中加入以下方法,讓其在反序列化過程當中執行 readResolve 方法時返回 sSingleton 對象。

private Object readResolve() throws ObjectStreamException {
    return sSingleton;
}

結語

有沒有一種方式實現的單例模式在任何狀況下都是一個單例呢？

—— 有。就是上面說的枚舉單例。枚舉，就能保證在任何狀況下都是單例的，而且是線程安全的。