【設計模式】單例模式

• 2020 年 7 月 9 日
• 筆記
• 設計模式

單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。這種類型的設計模式屬於創建型模式，它提供了一種創建對象的最佳方式。

這種模式涉及到一個單一的類，該類負責創建自己的對象，同時確保只有單個對象被創建。這個類提供了一種訪問其唯一的對象的方式，可以直接訪問，不需要實例化該類的對象。

注意：

• 單例類只能有一個實例。
• 單例類必須自己創建自己的唯一實例。
• 單例類必須給所有其他對象提供這一實例。

基本介紹

• 意圖：保證一個類僅有一個實例，並提供一個訪問它的全局訪問點。

• 主要解決：一個全局使用的類頻繁地創建與銷毀。

• 何時使用：當您想控制實例數目，節省系統資源的時候。

• 如何解決：判斷系統是否已經有這個單例，如果有則返回，如果沒有則創建。

• 關鍵程式碼：構造函數是私有的。

• 應用實例：
  • 1、一個班級只有一個班主任。
  • 2、Windows 是多進程多執行緒的，在操作一個文件的時候，就不可避免地出現多個進程或執行緒同時操作一個文件的現象，所以所有文件的處理必須通過唯一的實例來進行。
  • 3、一些設備管理器常常設計為單例模式，比如一個電腦有兩台印表機，在輸出的時候就要處理不能兩台印表機列印同一個文件。
• 優點：
  • 1、在記憶體里只有一個實例，減少了記憶體的開銷，尤其是頻繁的創建和銷毀實例（比如管理學院首頁頁面快取）。
  • 2、避免對資源的多重佔用（比如寫文件操作）。

• 缺點：沒有介面，不能繼承，與單一職責原則衝突，一個類應該只關心內部邏輯，而不關心外面怎麼樣來實例化。

• 使用場景：
  • 1、要求生產唯一序列號。
  • 2、WEB 中的計數器，不用每次刷新都在資料庫里加一次，用單例先快取起來。
  • 3、創建的一個對象需要消耗的資源過多，比如 I/O 與資料庫的連接等。

注意事項：getInstance() 方法中需要使用同步鎖 synchronized (Singleton.class) 防止多執行緒同時進入造成 instance 被多次實例化。

概括

所謂類的單例設計模式（Singleton Pattern），就是採取一定的方法保證在整個的軟體系統中，對某個類只能存在一個對象實例，並且該類只提供一個取得其對象實例的方法（靜態方法）。
這種類型的設計模式屬於創建型模式，它提供了一種創建對象的最佳方式。

比如 Hibernate 的 SessionFactory，它充當數據存儲源的代理，並負責創建 Session 對象。SessionFactory 並不是輕量級的，一般情況下，一個項目通常只需要一個 SessionFactory 就夠，這是就會使用到單例模式。

類圖：

角色分析：

1. Singleton：就是我們的單例對象，裡面將構造方法私有化，使外界不能訪問，並提供一個 getInstance() 類方法來供外界使用。

我的理解

一個類只有一個對象實例，即 單例模式。可以類比孤獨的喬治。
孤獨的喬治，是一隻加拉帕戈斯象龜平塔島象龜亞種個體。自1971年被發現到2012年確認死亡為止，被認為是平塔島象龜中已知的最後一個個體。它被認為是世界上最稀有的動物，也是加拉帕戈斯群島乃至全球物種保護的象徵之一。

單例設計模式八種方式

單例模式有八種方式：

1. 餓漢式（靜態常量）（推薦使用）

   餓漢：類載入的時候，把對象也創建出來了，很容易浪費空間，因為不知道什麼時候類就載入了，而對象如果不用，就造成了空間浪費。

2. 餓漢式（靜態程式碼塊）（推薦使用）

   比起靜態常量來說，靜態程式碼塊中可以寫很多判斷篩選資訊。

3. 懶漢式（執行緒不安全）

   懶漢：用的時候才去創建

4. 懶漢式（執行緒安全，同步方法）

5. 懶漢式（執行緒安全，同步程式碼塊）

6. 雙重檢查（推薦使用）
7. 靜態內部類（推薦使用）

8. 枚舉（推薦使用）

餓漢式（靜態常量）

餓漢式（靜態常量）應用實例步驟如下：

1. 構造器私有化（防止 new）
2. 類的內部創建對象
3. 向外暴露一個靜態的公共方法 getInstance()

程式碼演示：

package com.atguigu.singleton.type1;

public class SingletonTest01 {

    public static void main(String[] args) {
    //測試
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }

}

//餓漢式(靜態變數)
class Singleton {
    //1. 構造器私有化,  外部不能 new 
    private Singleton() {}

    //2.本類內部創建對象實例
    private final static Singleton instance = new Singleton();

    //3. 提供一個公有的靜態方法，返回實例對象
    public static Singleton getInstance() {
        return instance;
    }

}

優缺點說明：

1. 優點：這種寫法比較簡單，就是在類裝載的時候就完成實例化。避免了執行緒同步問題。
2. 缺點：在類裝載的時候就完成實例化，沒有達到 Lazy Loading 的效果。如果從始至終從未使用過這個實例，則會造成記憶體的浪費。
3. 這種方式基於 classloder 機制避免了多執行緒的同步問題，不過，instance 在類裝載時就實例化，在單例模式中大多數都是調用 getInstance 方法， 但是導致類裝載的原因有很多種，因此不能確定有其他的方式（或者其他的靜態方法）導致類裝載，這時候初始化 instance 就沒有達到 lazy loading 的效果。
4. 結論：這種單例模式可用，可能造成記憶體浪費。

餓漢式（靜態程式碼塊）

程式碼演示：

package com.atguigu.singleton.type2;

public class SingletonTest02 {

    public static void main(String[] args) {
        //測試
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }

}

//餓漢式(靜態變數) 
class Singleton {
    //1. 構造器私有化,  外部不能 new 
    private Singleton() {}

    //2.本類內部創建對象實例
    private static Singleton instance;

    static { // 在靜態程式碼塊中，創建單例對象（類裝載的時候執行）
        instance = new Singleton();
    }

    //3. 提供一個公有的靜態方法，返回實例對象
    public static Singleton getInstance() {
        return instance;
    }

}

優缺點說明：

1. 這種方式和上面的方式其實類似，只不過將類實例化的過程放在了靜態程式碼塊中，也是在類裝載的時候，就執行靜態程式碼塊中的程式碼，初始化類的實例。優缺點和上面是一樣的。
2. 結論：這種單例模式可用，但是可能造成記憶體浪費

懶漢式（執行緒不安全）

程式碼演示：

package com.atguigu.singleton.type3;

public class SingletonTest03 {

    public static void main(String[] args) {
        System.out.println("懶漢式 1 ， 執行緒不安全~");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }

}


class Singleton {

    private static Singleton instance;

    private Singleton() {}

    //提供一個靜態的公有方法，當使用到該方法時，才去創建 instance
    //即 懶漢式
    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

優缺點說明：

1. 起到了 Lazy Loading 的效果，但是只能在單執行緒下使用。
2. 如果在多執行緒下，一個執行緒進入了 if (singleton == null) 判斷語句塊，還未來得及往下執行（還未構造對象），另一個執行緒也通過了這個判斷語句，這時便會產生多個實例。所以在多執行緒環境下不可使用這種方式。
3. 結論：在實際開發中，不要使用這種方式。

懶漢式（執行緒安全，同步方法）

程式碼演示：

package com.atguigu.singleton.type4;

public class SingletonTest04 {

    public static void main(String[] args) {
        System.out.println("懶漢式 2 ， 執行緒安全~");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }

}


// 懶漢式(執行緒安全，同步方法)
class Singleton {
    private static Singleton instance;

    private Singleton() {}

    //提供一個靜態的公有方法，加入同步處理的程式碼，解決執行緒安全問題
    //即懶漢式
    public static synchronized Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

優缺點說明：

1. 解決了執行緒安全問題。
2. 效率太低了，每個執行緒在想獲得類的實例時候，執行 getInstance() 方法都要進行同步。而其實這個方法只執行一次實例化程式碼就夠了，後面的想獲得該類實例，直接 return 就行了。方法進行同步效率太低。
3. 結論：在實際開發中，不推薦使用這種方式。

懶漢式（執行緒安全，同步程式碼塊）

程式碼演示：

class Singleton {
    private static Singleton singleton;

    private Singleton() {}

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

優缺點說明：

1. 跟上面「懶漢式（執行緒不安全）」一樣，如果在多執行緒下，一個執行緒進入了 if (singleton == null) 判斷語句塊，還未來得及往下執行（還未構造對象），另一個執行緒也通過了這個判斷語句，這時便會產生多個實例。所以在多執行緒環境下不可使用這種方式。
2. 結論：不推薦使用

雙重檢查

程式碼演示：

package com.atguigu.singleton.type6;

public class SingletonTest06 {

    public static void main(String[] args) {
        System.out.println("雙重檢查");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }

}

// 懶漢式（執行緒安全，同步方法）
class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    //提供一個靜態的公有方法，加入雙重檢查程式碼，解決執行緒安全問題, 同時解決懶載入問題
    //同時保證了效率, 推薦使用
    public static synchronized Singleton getInstance() {
        //第一次檢查，可以保證在對象創建好之後，每個執行緒在想獲得類的實例不需要再進行同步
        //解決了「懶漢式(執行緒安全，同步方法)」的缺點
        if(instance == null) {
            synchronized (Singleton.class) {
                //第二次檢查，可以避免當多個執行緒擠進此語句時，創建多個實例
                //解決了「懶漢式(執行緒不安全)」的缺點
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

volatile：輕量級的 synchronized，只能修飾變數。讓修改值立即更新到主存，多執行緒情況下防止指令重排序。能保證此對象的同步創建，類似於原子性創建，不能被中斷，一次順序執行到底。由於 new 不是原子方法，所以執行當中有很多個步驟，可能被多執行緒插隊，導致創建錯誤，所以加入 volatile 保證同步創建，原子創建。
防止在 new 實例的時候，還沒初始化完，有其他執行緒進來，實例此時已經不為空，多執行緒拿到的實例數據就不一致，加了該關鍵字後，先初始化完成後再賦值給實例，即 輕量級同步。

精確地說就是，編譯器在用到這個變數時必須每次都小心地重新讀取這個變數的值，而不是使用保存在暫存器里的備份。

優缺點說明：

1. Double-Check 概念是多執行緒開發中常使用到的，如程式碼中所示，我們進行了兩次 if (singleton == null) 檢查，這樣就可以保證執行緒安全了。
2. 這樣，實例化程式碼只用執行一次，後面再次訪問時，判斷 if (singleton == null)，直接 return 實例化對象，也避免的反覆進行方法同步。
3. 執行緒安全；延遲載入；效率較高。
4. 結論：在實際開發中，推薦使用這種單例設計模式。

靜態內部類

程式碼演示：

package com.atguigu.singleton.type7;

public class SingletonTest07 {

    public static void main(String[] args) {
        System.out.println("使用靜態內部類完成單例模式");
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2); // true 
        System.out.println("instance.hashCode=" + instance.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }

}

// 靜態內部類完成，推薦使用
class Singleton {
    private static volatile Singleton instance;

    //構造器私有化
    private Singleton() {}

    //寫一個靜態內部類,該類中有一個靜態屬性 Singleton 
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    //提供一個靜態的公有方法，直接返回 SingletonInstance.INSTANCE
    public static synchronized Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

類中套類，既保證了不會裝載浪費空間，又保證了用的時候單一且執行緒安全。上來就創一個，可以避免多執行緒問題。
在類裝載的時候，靜態內部類不會裝載。
當調用的時候，靜態內部類才會被裝載，當類裝載的時候執行緒是安全的。

優缺點說明：

1. 這種方式採用了類裝載的機制來保證初始化實例時只有一個執行緒。
2. 靜態內部類方式在 Singleton 類被裝載時並不會立即實例化，而是在需要實例化時，調用 getInstance 方法，才會裝載 SingletonInstance 類，從而完成 Singleton 的實例化。
3. 類的靜態屬性只會在第一次載入類的時候初始化，所以在這裡，JVM 幫助我們保證了執行緒的安全性，在類進行初始化時，別的執行緒是無法進入的。
4. 優點：避免了執行緒不安全，利用靜態內部類特點實現延遲載入，效率高。
5. 結論：推薦使用。

枚舉

程式碼演示：

package com.atguigu.singleton.type8;

public class SingletonTest08 {
    public static void main(String[] args) {
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
        instance.sayOK();
    }
}

//使用枚舉，可以實現單例, 推薦
enum Singleton {
    INSTANCE; //屬性
    public void sayOK() {
        System.out.println("ok~");
    }
}

優缺點說明：

1. 這藉助 JDK1.5 中添加的枚舉來實現單例模式。不僅能避免多執行緒同步問題，而且還能防止反序列化重新創建新的對象。
2. 這種方式是《Effective Java》的作者 Josh Bloch 提倡的方式
3. 結論：推薦使用

單例模式在 JDK 應用的源碼分析

1. 我們 JDK 中，java.lang.Runtime 就是經典的單例模式(餓漢式)
2. 程式碼分析+Debug 源碼 + 程式碼說明
   

單例模式注意事項和細節說明

1. 單例模式保證了系統記憶體中該類只存在一個對象，節省了系統資源，對於一些需要頻繁創建銷毀的對象，使用單例模式可以提高系統性能。
2. 當想實例化一個單例類的時候，必須要記住使用相應的獲取對象的方法，而不是使用 new。
3. 單例模式使用的場景：需要頻繁的進行創建和銷毀的對象、創建對象時耗時過多或耗費資源過多（即：重量級對象），但又經常用到的對象、工具類對象、頻繁訪問資料庫或文件的對象（比如數據源、session 工廠等）

為什麼單例模式要創建一個對象，方法不是可以直接用類

問：靜態方法可以通過類來調用，其餘得創建對象來調用。那單例模式與一個類全是靜態方法在設計角度的差別是什麼呢？
答：因為單例模式可以充分的使用面向對象的封裝，繼承，多態；而一個類所有靜態方法不行，在設計角度遠不如單態設計靈活。