摘要：單件模式提供這個實例的全局訪問點。實現單件模式，需要私有構造器，一個靜態方法，一個靜態變量。設計到多線程問題，同步會降低程序效率。

擁有獨立且唯一的對象

這次講述的是單件模式，就是整個內容里只有一個實例化“唯一”對象。這么說可能有點拗口，這么說吧，比方說，線程池，緩存，注冊表，日志文件，甚至做JDBC中連接，關閉，增刪改查數據庫的Connection類（個人命名也許并不一樣）、工具類等等。這些東西往往是要實例一次，就能在整個項目中使用了。

單件模式并不難理解定義如下
單件模式：確保一個類中只有一個實例，并提供一個全局訪問點。
是的就這么一句話的定義。一般單件模式分為“懶漢式”和“餓漢式”做法

直接上代碼。

“懶漢式”做法

package singleton01;

public class Singleton01 {
    // 利用一個靜態變量記錄本類當中唯一的實例(mySingleton01)
    private  static Singleton01 mySingleton01 = null;

    public Singleton01() {
    }

    // synchronized關鍵字：線程同步鎖,在多線程中去互斥地訪問臨界資源
    // 迫使每個線程在進入方法之前，要先等別的線程執行完離開方法后才能執行，達到多個線程排隊，不會造成有多個線程同時進入這個方法
    // 即是同步。但同步會使程序效率降低
    public static synchronized Singleton01 getInstance() {
        if (mySingleton01 == null) {
            mySingleton01 = new Singleton01();
            System.out.println("Singleton01被實例化了");
        }
        System.out.println("返回Singleton01實例");
        return mySingleton01;
    }
    /**
     * 上面方法就是常說了“懶漢式”做法，大體意思就是當誰需要類方法時采取實例化
     */
}

package singleton01;

public class TestMain {
    public static void main(String[] args) {
        // 打印出前兩行結果
        Singleton01 singleton01 = Singleton01.getInstance();

        // 此時我們看到第二次調用類方法時候，沒有去實例對象
        // 這里涉及并發方面問題，暫時沒學習并發，具體怎么個原理我也不知道...
        Singleton01 singleton02 = Singleton01.getInstance();
    }
}

效果圖1

效果圖2

之前的做法中我們用到了synchronized，就是為了防止線程啟動的隨機性找出變量混亂，我這個小例子可能看不出來什么。但實際上同步線程（synchronized）會使得程序效率大幅降低。利用雙重檢查加鎖可以有效解決此問題，

使用雙重檢查加鎖

package singleton01;

public class singleton02 {
    // 利用雙重檢查加鎖,先檢查實例是否已經創建，如果沒創建，就進行同步。
    // volatile：instance變量被初始化singleton02實例時，多個線程會正確處理instance變量
    // 線程是具有隨機性的，與程序執行順序無關。
    private volatile static singleton02 instance=null;

    public singleton02() {        
    }

    public static singleton02 getInstance() {
        if (instance == null) {
            // 檢查實例，不存在的話進入同步區域,只有第一次才執行這里
            synchronized (singleton02.class) {
                System.out.println("進入同步區域");
                if (instance == null) {
                    System.out.println("instance被實例化了");
                    instance = new singleton02();
                }
            }
        }
        System.out.println("返回instance實例");
        return instance;
    }
}

package singleton01;

public class TestMain02 {
    public static void main(String[] args) {
        //第一次進入方法會進入同步區實例化
        singleton02 singleton02 = null;
        singleton02 = singleton02.getInstance();
        
        //當第二次進入時，已有實例，不會同步了，直接返回實例.
        singleton02 singleton03 = null;
        singleton03 = singleton02.getInstance();    
    }

}

效果圖

"餓漢式"做法

package singleton02;

public class Singleton {
    /**
     * “餓漢式”：加載這個類時立刻創建本類中唯一的單件實例，
     */
    private static Singleton uniqueInstance = new Singleton();

    private Singleton() {

    }

    public static Singleton getInstance() {
        System.out.println("返回實例實例");
        return uniqueInstance;
    }
}

package singleton02;

public class TestMain {
    public static void main(String[] args) {
        //直接返回實例
        Singleton singleton = Singleton.getInstance();
    }
}

效果圖

注：雙重檢查加鎖不適用與1.4之前的java版本。

要點：
1、單件模式確保程序中一個類最多只有一個實例。
2、單件模式提供這個實例的全局訪問點。
3、實現單件模式，需要私有構造器，一個靜態方法，一個靜態變量。
4、設計到多線程問題，同步會降低程序效率。

感謝你看到這里，至此單件模式內容結束，本人文筆隨便，若有不足或錯誤之處望給予指點，90度彎腰~~~很快我會發布下一個設計模式內容，生命不息，編程不止！

參考書籍：《Head First 設計模式》