Java設計模式-單例模式八種寫法及注意事項

單例設計模式介紹

所謂類的單例設計模式，就是採取一定的方法保證在整個軟件系統種，對某個類只能存在一個對象實例，並且該類只提供一個取得其對象實例的方法。

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

單例模式的八種寫法

• 餓漢式（靜態常量）可以用
• 餓漢式（靜態代碼塊）可以用
• 懶漢式（線程不安全）不可用
• 懶漢式（線程安全，同步方法）可以用，效率低
• 懶漢式（線程安全，同步代碼塊）不可用
• 雙重檢查 （推薦使用）
• 靜態內部類 （推薦使用）
• 枚舉 （推薦使用）

餓漢式（靜態常量）應用實例

步驟如下：
- 構造器私有化（防止 外部new創建實例）
- 類的內部創建對象
- 向外暴露一個靜態的公共方法
代碼示例：

public class SingletonTest01 {
    public static void main(String[] args) {
        Singleton instance=Singleton.getInstance();
        Singleton instance2=Singleton.getInstance();
        System.out.println(instance==instance2);
        System.out.println("instance.hascode="+instance.hashCode());
        System.out.println("instance2.hascode="+instance2.hashCode());
    }
}
class Singleton{
    //1、構造器私有化（防止 外部new創建實例）
    private Singleton(){
    }
    //2、本類內部創建對象實例
    private final static Singleton instance =new Singleton();
    //3、提供一個公有的靜態方法，返回實例對象
    public static Singleton getInstance(){
        return instance;
    }
}

測試輸出：

true
instance.hascode=460141958
instance2.hascode=460141958

優缺點說明：

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

餓漢式（靜態代碼塊）

示例:

public class SingletonTest02 {
    public static void main(String[] args) {
        Singleton instance= Singleton.getInstance();
        Singleton instance2= Singleton.getInstance();
        System.out.println(instance==instance2);
        System.out.println("instance.hascode="+instance.hashCode());
        System.out.println("instance2.hascode="+instance2.hashCode());
    }
}

class Singleton{
    //1、構造器私有化（防止 外部new創建實例）
    private Singleton(){
    }
    //2、本類內部創建對象實例
    private static Singleton instance;
    //3、在靜態代碼塊中，創建單例對象
    static{
        instance=new Singleton();
    }
    //4、提供一個公有的靜態方法，返回實例對象
    public static Singleton getInstance(){
        return instance;
    }
}

測試輸出：

true
instance.hascode=1908153060
instance2.hascode=1908153060

優缺點說明：

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

懶漢式（線程不安全）

示例：

public class SingletonTest03 {
    public static void main(String[] args) {
        Singleton instance= Singleton.getInstance();
        Singleton instance2= Singleton.getInstance();
        System.out.println(instance==instance2);
        System.out.println("instance.hascode="+instance.hashCode());
        System.out.println("instance2.hascode="+instance2.hashCode());
    }
}
class Singleton{
    private static Singleton instance;
    private Singleton(){}
    //提供一個靜態的公有方法，當使用到該方法時，纔去創建instance
    //即懶漢式
    public static Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

測試輸出：

true
instance.hascode=460141958
instance2.hascode=460141958

優缺點：

• 起到了lazy loading的效果，但是只能在單線程下使用。
• 如果在多線程下，一個線程進入了if(singleton == null)判斷語句塊，還未來得及往下執行，另一個線程也通過了這個判斷語句，這時便會產生多個實例。所以在多線程環境下不可使用這種方式
• 結論：在實際開發中，不要使用這種方式。

懶漢式（線程安全，同步方法）

示例：

public class SingletonTest04 {
    public static void main(String[] args) {
        Singleton instance= Singleton.getInstance();
        Singleton instance2= Singleton.getInstance();
        System.out.println(instance==instance2);
        System.out.println("instance.hascode="+instance.hashCode());
        System.out.println("instance2.hascode="+instance2.hashCode());
    }
}

class Singleton{
    private static Singleton instance;
    private Singleton(){}
    //提供一個靜態的公有方法，當使用到該方法時，纔去創建instance
    //即懶漢式
    //加入同步處理代碼解決線程安全問題
    public static synchronized Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

測試輸出：

true
instance.hascode=460141958
instance2.hascode=460141958

優缺點說明：

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

懶漢式（線程安全，同步代碼塊）

示例：

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

結論：不可取，有可能多個線程同時進入了if(instance==null)中，實際上並非線程安全

懶漢式（雙重檢查）

class Singleton{
    private static volatile Singleton instance;
    private Singleton(){}
    //提供一個靜態的公有方法，當使用到該方法時，纔去創建instance
    //即懶漢式
    //雙重檢查方式
    public static Singleton getInstance(){
        if(instance==null){
            synchronized (Singleton.class){
                if(instance==null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

結論：Double-Check概念是多線程開發中常使用到的，完美解決了線程安全問題，同時實現了懶加載，效率較高，推薦使用

靜態內部類

class Singleton{
	//構造器私有化
    private Singleton(){}
    //寫一個靜態內部類，該類中有一個靜態屬性Singleton
    private static class SingletonInstance{
        private static final Singleton Instance=new Singleton();
    }
    //使用靜態內部類方式
    public static Singleton getInstance(){
      return SingletonInstance.Instance;
    }
}

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

枚舉

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應用源碼分析

如java.lang.runtime是一個經典的單例模式。

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

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