java設計模式之【單例模式】用法比較

https://blog.csdn.net/luofen521/article/details/51788230

1.定義

確保某個類只有一個實例，能自行實例化並向整個系統提供這個實例。

2.應用場景

1. 當產生多個對象會消耗過多資源，比如IO和數據操作
2. 某種類型的對象只應該有且只有一個，比如Android中的Application。

3.考慮情況

1. 多線程造成實例不唯一。
2. 反序列化過程生成了新的實例。

4.實現方式

4.1普通單例模式

/**
 * 普通模式
 * @author josan_tang
 */
public class SimpleSingleton {
    //1.static單例變量
    private static SimpleSingleton instance;

    //2.私有的構造方法
    private SimpleSingleton() {

    }

    //3.靜態方法爲調用者提供單例對象
    public static SimpleSingleton getInstance() {
        if (instance == null) {
            instance = new SimpleSingleton();
        }
        return instance;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22

在多線程高併發的情況下，這樣寫會有明顯的問題，當線程A調用getInstance方法，執行到16行時，檢測到instance爲null，於是執行17行去實例化instance，當17行沒有執行完時，線程B又調用了getInstance方法，這時候檢測到instance依然爲空，所以線程B也會執行17行去創建一個新的實例。這時候，線程A和線程B得到的instance就不是一個了，這違反了單例的定義。

4.2 餓漢單例模式

/**
 * 餓漢單例模式
 * @author josan_tang
 */
public class EHanSingleton {
    //static final單例對象，類加載的時候就初始化
    private static final EHanSingleton instance = new EHanSingleton();

    //私有構造方法，使得外界不能直接new
    private EHanSingleton() {
    }

    //公有靜態方法，對外提供獲取單例接口
    public static EHanSingleton getInstance() {
        return instance;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

餓漢單例模式解決了多線程併發的問題，因爲在加載這個類的時候，就實例化了instance。當getInstatnce方法被調用時，得到的永遠是類加載時初始化的對象（反序列化的情況除外）。但這也帶來了另一個問題，如果有大量的類都採用了餓漢單例模式，那麼在類加載的階段，會初始化很多暫時還沒有用到的對象，這樣肯定會浪費內存，影響性能，我們還是要傾向於4.1的做法，在首次調用getInstance方法時才初始化instance。請繼續看4.3用法。

4.3懶漢單例模式

import java.io.Serializable;

/**
 * 懶漢模式
 * @author josan_tang
 */
public class LanHanSingleton {
    private static LanHanSingleton instance;

    private LanHanSingleton() {

    }

    /**
     * 增加synchronized關鍵字，該方法爲同步方法，保證多線程單例對象唯一
     */
    public static synchronized LanHanSingleton getInstance() {
        if (instance == null) {
            instance = new LanHanSingleton();
        }
        return instance;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24

與4.1的唯一區別在於getInstance方法前加了synchronized 關鍵字，讓getInstance方法成爲同步方法，這樣就保證了當getInstance第一次被調用，即instance被實例化時，別的調用不會進入到該方法，保證了多線程中單例對象的唯一性。

優點：單例對象在第一次調用才被實例化，有效節省內存，並保證了線程安全。

缺點：同步是針對方法的，以後每次調用getInstance時（就算intance已經被實例化了），也會進行同步，造成了不必要的同步開銷。不推薦使用這種方式。

4.4 Double CheckLock(DCL)單例模式

/**
 * Double CheckLock(DCL)模式
 * @author josan_tang
 *
 */
public class DCLSingleton {
    //增加volatile關鍵字，確保實例化instance時，編譯成彙編指令的執行順序
    private volatile static DCLSingleton instance;

    private DCLSingleton() {

    }

    public static DCLSingleton getInstance() {
        if (instance == null) {
            synchronized (DCLSingleton.class) {
                //當第一次調用getInstance方法時，即instance爲空時，同步操作，保證多線程實例唯一
                //當以後調用getInstance方法時，即instance不爲空時，不進入同步代碼塊，減少了不必要的同步開銷
                if (instance == null) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27

DCL失效：

在JDK1.5之前，可能會有DCL實現的問題，上述代碼中的20行，在Java裏雖然是一句代碼，但它並不是一個真正的原子操作。

instance = new DCLSingleton();

• 1

它編譯成最終的彙編指令，會有下面3個階段：

1. 給DCLSingleton實例分配內存
2. 調用DCLSingleton的構造函數，初始化成員變量。
3. 將instance指向分配的內存空間（這個操作以後，instance纔不爲null）

在jdk1.5之前，上述的2、3步驟不能保證順序，也就是說有可能是1-2-3，也有可能是1-3-2。如果是1-3-2，當線程A執行完步驟3（instance已經不爲null），但是還沒執行完2，線程B又調用了getInstance方法，這時候線程B所得到的就是線程A沒有執行步驟2（沒有執行完構造函數）的instance，線程B在使用這樣的instance時，就有可能會出錯。這就是DCL失效。

在jdk1.5之後，可以使用volatile關鍵字，保證彙編指令的執行順序，雖然會影響性能，但是和程序的正確性比起來，可以忽悠不計。

Java內存模型

優點：第一次執行getInstance時instance才被實例化，節省內存；多線程情況下，基本安全；並且在instance實例化以後，再次調用getInstance時，不會有同步消耗。

缺點：jdk1.5以下，有可能DCL失效；Java內存模型影響導致失效；jdk1.5以後，使用volatile關鍵字，雖然能解決DCL失效問題，但是會影響部分性能。

4.5 靜態內部類單例模式

/**
 * 靜態內部類實現單例模式
 * @author josan_tang
 *
 */
public class StaticClassSingleton {
    //私有的構造方法，防止new
    private StaticClassSingleton() {

    }

    public static StaticClassSingleton getInstance() {
        return StaticClassSingletonHolder.instance;
    }

    /**
     * 靜態內部類
     */
    private static class StaticClassSingletonHolder {
        //第一次加載內部類的時候，實例化單例對象
        private static final StaticClassSingleton instance = new StaticClassSingleton();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24

第一次加載StaticClassSingleton類時，並不會實例化instance，只有第一次調用getInstance方法時，Java虛擬機纔會去加載StaticClassSingletonHolder類，繼而實例化instance，這樣延時實例化instance，節省了內存，並且也是線程安全的。這是推薦使用的一種單例模式。

4.6 枚舉單例模式

/**
 * 枚舉單例模式
 * @author josan_tang
 *
 */
public enum EnumSingleton {
    //枚舉實例的創建是線程安全的，任何情況下都是單例（包括反序列化）
    INSTANCE;

    public void doSomething(){

    } 
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

枚舉不僅有字段還能有自己的方法，並且枚舉實例創建是線程安全的，就算反序列化時，也不會創建新的實例。除了枚舉模式以外，其他實現方式，在反序列化時都會創建新的對象。

爲了防止對象在反序列化時創建新的對象，需要加上如下方法：

    private Object readResole() throws ObjectStreamException {
        return instance;
    }

• 1
• 2
• 3

這是一個鉤子函數，在反序列化創建對象時會調用它，我們直接返回instance就是說，不要按照默認那樣去創建新的對象，而是直接將instance返回。

4.7 容器單例模式

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

/**
 * 容器單例模式
 * @author josan_tang
 */
public class ContainerSingleton {
    private static Map<String, Object> singletonMap = new HashMap<String, Object>();

    //單例對象加入到集合，key要保證唯一性
    public static void putSingleton(String key, Object singleton){
        if (key != null && !"".equals(key) && singleton != null) {
            if (!singletonMap.containsKey(key)) {   //這樣防止集合裏有一個類的兩個不同對象
                singletonMap.put(key, singleton);   
            }
        }
    }

    //根據key從集合中得到單例對象
    public static Object getSingleton(String key) {
        return singletonMap.get(key);
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25

在程序初始化的時候，講多種單例類型對象加入到一個單例集合裏，統一管理。在使用時，通過key從集合中獲取單例對象。這種方式多見於系統中的單例，像安卓中的系統級別服務就是採用集合形式的單例模式，比如常用的LayoutInfalter，我們一般在Fragment中的getView方法中使用如下代碼:

View view = LayoutInflater.from(context).inflate(R.layout.xxx, null);

• 1

其實LayoutInflater.from(context)就是得到LayoutInflater實例，看下面的Android源碼：

    /**
     * Obtains the LayoutInflater from the given context.
     */
    public static LayoutInflater from(Context context) {
        //通過key，得到LayoutInflater實例
        LayoutInflater LayoutInflater =
                (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        if (LayoutInflater == null) {
            throw new AssertionError("LayoutInflater not found.");
        }
        return LayoutInflater;
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

總結

不管是那種形式實現單例模式，其核心思想都是將構造方法私有化，並且通過靜態方法獲取一個唯一的實例。在獲取過程中需要保證線程安全、防止反序列化導致重新生成實例對象。選擇哪種實現方式看情況而定，比如是否高併發、JDK版本、單例對象的資源消耗等。

名稱	優點	缺點	備註
簡單模式	實現簡單	線程不安全
餓漢模式	線程安全	內存消耗太大
懶漢模式	線程安全	同步方法消耗比較大
DCL模式	線程安全，節省內存	jdk版本受限、高併發會導致DCL失效	推薦使用
靜態內部類模式	線程安全、節省內存	實現比較麻煩	推薦使用
枚舉模式	線程安全、支持反序列化	個人感覺比較怪異
集合模式	統一管理、節省資源	線程不安全