摘要：單例模式的優缺點優點單例模式在內存中只有一個實例，減少了內存開支，尤其是頻繁的創建和銷毀實例。單例模式對測試不利。單例模式與單一職責原則有沖突，一個類應該只實現一個邏輯，而不用關心它是否是單例的。資源源碼參考設計模式之禪

原文地址：xeblog.cn/articles/16

確保某一個類只有一個實例，而且自行實例化并向整個系統提供這個實例。

UML類圖

單例類的構造函數是 private 內部私有的，確保外部不能通過 new 的方式創建新對象，內部自行實例化，并對外提供一個訪問該單一實例的靜態的方法 Instance() 。

/**
 * 普通餓漢式
 *
 * @author anlingyi
 */
public class Singleton {
    /**
     * 類加載時進行實例化對象
     */
    private static final Singleton SINGLETON = new Singleton();

    /**
     * 私有構造，防止外部new對象
     */
    private Singleton() {

    }

    /**
     * 通過靜態方法獲取對象實例
     *
     * @return
     */
    public static Singleton getInstance() {
        return SINGLETON;
    }

    public void say() {
        System.out.println("普通餓漢式：Hello World!");
    }
}

調用方式：

Singleton singleton = Singleton.getInstance();
singleton.say();

優缺點

優點： 類加載時就進行實例化，之后的操作效率會很高。
缺點： 由于類加載時就進行實例化，如果后續不對此類進行任何操作，就會導致內存的浪費。

/**
 * 懶漢式（線程不安全）
 *
 * @author anlingyi
 */
public class SingletonTwo {

    private static SingletonTwo instance;

    /**
     * 私有構造，防止外部new對象
     */
    private SingletonTwo() {

    }

    /**
     * 通過靜態方法獲取對象實例
     *
     * @return
     */
    public static SingletonTwo getInstance() {
        if(instance == null) {
            instance = new SingletonTwo();
        }

        return instance;
    }

    public void say() {
        System.out.println("懶漢式（線程不安全）：Hello World!");
    }
}

調用方式：

SingletonTwo singleton = SingletonTwo.getInstance();
singleton.say();

優缺點

優點： 在第一次調用的時候才進行實例化。
缺點： 當多個線程同時進入到 if(instance == null) {...} 時，會創建多個對象。

/**
 * 同步鎖懶漢式（線程安全，效率低）
 *
 * @author anlingyi
 */
public class SingletonThree {

    private static SingletonThree instance;

    /**
     * 私有構造，防止外部new對象
     */
    private SingletonThree() {

    }

    /**
     * 通過靜態方法獲取對象實例
     *
     * @return
     */
    public static synchronized SingletonThree getInstance() {
        if(instance == null) {
            instance = new SingletonThree();
        }

        return instance;
    }

    public void say() {
        System.out.println("同步鎖懶漢式（線程安全，效率低）：Hello World!");
    }
}

調用方式：

SingletonThree singleton = SingletonThree.getInstance();
singleton.say();

優缺點

優點： 在第一次調用的時候才進行實例化，且線程安全。
缺點： 使用 synchronized 的方式對方法加鎖，會影響效率。

/**
 * 雙重校驗鎖懶漢式（線程安全，且多線程環境下可以保持高性能）
 *
 * @author anlingyi
 */
public class SingletonFour {

    /**
     * volatile是為了防止指令重排序
     */
    private static volatile SingletonFour instance;

    /**
     * 私有構造，防止外部new對象
     */
    private SingletonFour() {

    }

    /**
     * 通過靜態方法獲取對象實例
     *
     * @return
     */
    public static SingletonFour getInstance() {
        if(instance == null) {
            synchronized (SingletonFour.class) {
                if(instance == null) {
                    instance = new SingletonFour();
                }
            }
        }

        return instance;
    }

    public void say() {
        System.out.println("雙重校驗鎖懶漢式（線程安全，且多線程環境下可以保持高性能）：Hello World!");
    }
}

調用方式：

SingletonFour singleton = SingletonFour.getInstance();
singleton.say();

優缺點

優點： 在第一次調用的時候才進行實例化，且線程安全，效率較高。
缺點： 實現復雜，且 volatile 需要在JDK1.5之后的版本才能確保安全。

/**
 * 靜態內部類懶漢式
 *
 * @author anlingyi
 */
public class SingletonFive {

    /**
     * 私有構造，防止外部new對象
     */
    private SingletonFive() {

    }

    /**
     * 通過靜態方法獲取對象實例
     *
     * @return
     */
    public static SingletonFive getInstance() {
        return Singleton.SINGLETON;
    }

    public void say() {
        System.out.println("靜態內部類懶漢式：Hello World!");
    }

    /**
     * 靜態內部類實例化對象
     */
    private static class Singleton {
        /**
         * 類加載時進行實例化對象
         */
        private static final SingletonFive SINGLETON = new SingletonFive();
    }
}

調用方式：

SingletonFive singleton = SingletonFive.getInstance();
singleton.say();

優缺點

優點： 只有在調用 getInstance() 方法的時候，靜態內部類才會被加載，從而對主類（我們需要的類）進行實例化，即線程安全，又效率高。
缺點： 多創建一個類。

/**
 * 枚舉類餓漢式（防止反序列化）
 *
 * @author anlingyi
 */
public enum  SingletonSix {
    INSTANCE;

    public void say() {
        System.out.println("枚舉類餓漢式（防止反序列化）：Hello World!");
    }
}

調用方式：

SingletonSix singleton = SingletonSix.INSTANCE;
singleton.say();

優缺點

優點： 實現簡單，防止反序列化生成多個實例，且線程安全。
缺點： Enum 需在JDK1.5之后版本使用。

單例模式在內存中只有一個實例，減少了內存開支，尤其是頻繁的創建和銷毀實例。

由于只生成一個實例，所以減少了系統的性能開銷。

避免對資源的多重占用，例如寫文件操作。

單例模式可以在系統設置全局的訪問點，優化和共享資源訪問。

單例模式不易擴展，若要擴展，除了修改代碼外別無他法。

單例模式對測試不利。

單例模式與單一職責原則有沖突，一個類應該只實現一個邏輯，而不用關心它是否是單例的。

源碼

《設計模式之禪》