單例模式 Singleton

目的：保證一個類別只會產生一個物件，而且要提供存取該物件的統一方法

單例模式是一個簡單易懂的模式，下面的程式碼很簡單的就達到這樣的需求： 一開始我們就直接new出這個類別的實體物件，並且將constructor宣告為private， 這樣其他程式就無法再new出新物件，如此一來就能保證這個類別只會存在一個實體物件， 這種寫法因為一開始就已經建立物件，因此也稱為貪婪單例模式(Greed Singleton)。

public class SingletonGreed {
    // 一開始就建立物件，這樣只要一直回傳這個物件就是簡單的singleton
    private static SingletonGreed instance  = new SingletonGreed();

    // private constructor，這樣其他物件就沒辦法直接用new來取得新的實體
    private SingletonGreed(){}

    // 因為constructor已經private，所以需要另外提供方法讓其他程式調用這個類別
    public static SingletonGreed getInstance(){
        return instance;
    }
}

假如建立這個物件需要耗費很多資源，可是程式運行中不一定會需要它，我們希望只有在第一次getInstance被呼叫的時候才花費資源來建立物件，code就要修改一下

public class Singleton {
    private static Singleton instance;

    private Singleton(){
        // 這裡面跑很了多code，建立物件需要花費很多資源
    }

    public static Singleton getInstance(){
        // 第一次被呼叫的時候再建立物件
        if(instance == null){
            instance = new Singleton();
        } 
        return instance;
    }
}

以上程式看起來沒問題，不過如果是多執行緒的情況下呼叫getInstance，可能第一個執行緒跑到instance = new Singleton()時，將時間讓給第二個 執行緒，因此第二個執行緒也執行了instance = new Singleton()，造成同時new了兩個新的物件。

/**
 * 單例模式測試
 */
public class SingletonTest extends Thread {
    String myId;
    public SingletonTest(String id) {
        myId = id;
    }

    // 執行緒執行的時候就去呼叫Singleton.getInstance()
    public void run() {
        Singleton singleton = Singleton.getInstance();
        if(singleton != null){
            // 用hashCode判斷前後兩次取到的Singleton物件是否為同一個
            System.out.println(myId+"產生 Singleton:" + singleton.hashCode());               
        }
    }

    public static void main(String[] argv) {
        /*
        // 單執行緒的時候，s1與s2確實為同一個物件
        Singleton s1  =  Singleton.getInstance();
        Singleton s2  =  Singleton.getInstance();
        System.out.println("s1:"+s1.hashCode() + " s2:" + s2.hashCode());
        System.out.println();
        */

        // 兩個執行緒同時執行
        Thread t1 = new SingletonTest("執行緒T1"); // 產生Thread物件
        Thread t2 = new SingletonTest("執行緒T2"); // 產生Thread物件
        t1.start(); // 開始執行t1.run()
        t2.start();
    }
}

為了解決這樣的問題，可以用synchronized修飾來解決這個問題，讓getInstance方法被調用的時候被lock住，就不會同時產生兩個物件。

public class Singleton {
    private static Singleton instance;


    private Singleton(){
        // 這裡面跑很了多code，建立物件需要花費很多資源
    }

    // 多執行緒時使用synchronized保證Singleton一定是單一的 
    public static synchronized Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        } 
        return instance;
    }
}

上面這樣的寫法，synchronized整個方法會造成執行效能會變差，實際上需要lock住的只有創造物件的過程，也就是new Singleton這段程式碼而已， 因此可以將synchronized搬到getInstance方法內來加快程式的效能。

public class Singleton {
    private static Singleton instance;


    private Singleton(){
        // 這裡面跑很了多code，建立物件需要花費很多資源
    }

    // 多執行緒時，當物件需要被建立時才使用synchronized保證Singleton一定是單一的 ，增加程式校能
    public static Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }    
            }
        } 
        return instance;
    }
}

由這個簡單的單例模式可以看到，一樣的設計模式在不同的情況也是會有不同的變化。 設計模式不會是一段固定的程式碼，而是一種如何解決特定問題的概念。