java程式設計建立型設計模式單例模式的七種範例

2022-02-11 10:01:43

1.什麼是單例模式？

所謂類的單例設計模式，就是採取一定的方法保證在整個的軟體系統中，對某個類只能存在一個物件範例，並且該類只提供一個取得其物件範例的方法(靜態方法)。

比如Hibernate的 SessionFactory，它充當資料儲存源的代理，並負責建立Session物件。SessionFactory並不是輕量級的，一般情況下，一個專案通常只需要一個SessionFactory就夠，這是就會使用到單例模式。

這篇文章中，我將給出單例模式的七種寫法：

餓漢式（靜態常數）
餓漢式（靜態程式碼塊）
懶漢式（執行緒不安全）
懶漢式（執行緒安全，同步方法）
雙重校驗鎖
靜態內部類
列舉

以上七種寫法中標紅的是推薦使用的，如果說你能保證你的程式中單例類的範例一定會使用到，那麼餓漢式也是推薦使用的。

2.七種寫法

2.1 餓漢式（靜態常數）

package com.szh.singleton.type1;
/**
 * 餓漢式(靜態變數)
 */
class Singleton {
    // 本類內部建立物件範例
    private static final Singleton INSTANCE = new Singleton();
    // 構造方法私有化, 防止外部new物件
    private Singleton() {}
    // 提供一個公有的靜態方法，返回範例物件
    public static Singleton getInstance() {
        return INSTANCE;
    }
}
public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

優缺點說明：

優點: 這種寫法比較簡單，就是在類裝載的時候就完成範例化。避免了執行緒同步問題。

缺點: 在類裝載的時候就完成範例化，沒有達到Lazy Loading 的效果。如果從始至終從未使用過這個範例，則會造成記憶體的浪費。

這種方式基於classloder機制避免了多執行緒的同步問題，不過，instance在類裝載時就範例化，在單例模式中大多數都是呼叫getInstance方法，但是導致類裝載的原因有很多種，因此不能確定有其他的方式(或者其他的靜態方法）導致類裝載，這時候初始化 instance就沒有達到lazy loading 的效果。

結論:這種單例模式可用，可能造成記憶體浪費。

2.2 餓漢式（靜態程式碼塊）

package com.szh.singleton.type2;
/**
 * 餓漢式(靜態程式碼塊)
 */
class Singleton {
    private static final Singleton INSTANCE;
    // 構造方法私有化, 防止外部new物件
    private Singleton() {}
    // 靜態程式碼塊, 完成物件的範例建立
    static {
        INSTANCE = new Singleton();
    }
    // 提供一個公有的靜態方法，返回範例物件
    public static Singleton getInstance() {
        return INSTANCE;
    }
}
public class SingletonTest02 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

優缺點說明：

這種方式和第一種方式其實類似，只不過將類範例化的過程放在了靜態程式碼塊中，也是在類裝載的時候，就執行靜態程式碼塊中的程式碼，初始化類的範例。優缺點和上面是一樣的。

結論:這種單例模式可用，但是可能造成記憶體浪費。

2.3 懶漢式（執行緒不安全）

package com.szh.singleton.type3;
import java.util.Objects;
 
/**
 * 懶漢式(執行緒不安全)
 */
class Singleton {
    private static Singleton instance;
    // 構造方法私有化, 防止外部new物件
    private Singleton() {}
    // 提供一個公有的靜態方法，返回範例物件
    public static Singleton getInstance() {
        if (Objects.isNull(instance)) {
            instance = new Singleton();
        }
        return instance;
    }
}
public class SingletonTest03 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

優缺點說明：

起到了Lazy Loading 的效果，但是隻能在單執行緒下使用。

如果在多執行緒下，一個執行緒進入了if (singleton== null)判斷語句塊，還未來得及往下執行，另一個執行緒也通過了這個判斷語句，這時便會產生多個範例。所以在多執行緒環境下不可使用這種方式。

結論: 在實際開發中，不要使用這種方式。

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

package com.szh.singleton.type4;
import java.util.Objects;
/**
 * 懶漢式(執行緒安全, 雙重校驗鎖)
 */
class Singleton {
    private static Singleton instance;
    // 構造方法私有化, 防止外部new物件
    private Singleton() {}
    // 提供一個公有的靜態方法，返回範例物件
    public static synchronized Singleton getInstance() {
        if (Objects.isNull(instance)) {
            instance = new Singleton();
        }
        return instance;
    }
}
public class SingletonTest04 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

優缺點說明：

解決了執行緒安全問題。

效率太低了，每個執行緒在想獲得類的範例時候，執行getInstance()方法都要進行同步。而其實這個方法只執行一次範例化程式碼就夠了，後面的想獲得該類範例，直接return就行了。方法進行同步效率太低。

結論: 在實際開發中，不推薦使用這種方式。

2.5 雙重校驗鎖

package com.szh.singleton.type5;
import java.util.Objects;
/**
 * 懶漢式(執行緒安全)
 */
class Singleton {
    private static volatile Singleton instance;
    // 構造方法私有化, 防止外部new物件
    private Singleton() {}
    // 提供一個公有的靜態方法，返回範例物件
    public static Singleton getInstance() {
        if (Objects.isNull(instance)) {
            synchronized (Singleton.class) {
                if (Objects.isNull(instance)) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
public class SingletonTest05 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

優缺點說明：

Double-Check概念是多執行緒開發中常使用到的，如程式碼中所示，我們進行了兩次if (singleton ==- null)檢查，這樣就可以保證執行緒安全了。

這樣，範例化程式碼只用執行一次，後面再次存取時，判斷if(singleton == null)，直接return 範例化物件，也避免的反覆進行方法同步。

執行緒安全;延遲載入;效率較高。

結論: 在實際開發中，推薦使用這種單例設計模式。

2.6 靜態內部類

package com.szh.singleton.type6;
import java.util.Objects;
/**
 * 靜態內部類
 */
class Singleton {
    // 構造方法私有化, 防止外部new物件
    private Singleton() {}
    // 定義靜態內部類
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    // 提供一個公有的靜態方法，返回靜態內部類中的範例物件
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}
public class SingletonTest06 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

優缺點說明：

這種方式採用了類裝載機制來保證初始化範例時只有一個執行緒。

靜態內部類方式在Singleton類被裝載時並不會立即範例化，而是在需要範例化時，呼叫getInstance方法，才會裝載SingletonInstance類，從而完成Singleton的範例化。

類的靜態屬性只會在第一次載入類的時候初始化，所以在這裡，JVM幫助我們保證了執行緒的安全性，在類進行初始化時，別的執行緒是無法進入的。

優點: 避免了執行緒不安全，利用靜態內部類特點實現延遲載入，效率高。

結論: 推薦使用。

2.7 列舉

package com.szh.singleton.type7;
/**
 * 列舉
 */
enum Singleton {
    INSTANCE;
}
public class SingletonTest07 {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.INSTANCE;
        Singleton singleton2 = Singleton.INSTANCE;
        System.out.println(singleton1 == singleton2);
        System.out.println("singleton1的hashCode = " + singleton1.hashCode());
        System.out.println("singleton2的hashCode = " + singleton2.hashCode());
    }
}

優缺點說明：

藉助JDK1.5中新增的列舉來實現單例模式。不僅能避免多執行緒同步問題，而且還能防止反序列化重新建立新的物件。

這種方式是Effective Java作者Josh Bloch提倡的方式。

結論: 推薦使用。