第3條：用私有構造器或者枚舉類型強化Singleleton屬性

實現Singleton模式，需要要把構造器保持爲私有的，並導出公有的靜態成員，以便允許客戶端能夠訪問該類的唯一實例。

1.餓漢式

餓漢式(Eager mode)：單例對象是個 final域，在類加載期間，就實例化一個對象交給自己的引用instance，如：

// Singleton with Eager mode
public class SingletonA
{
    //實例化一個對象交給自己的引用
    private static final instance = new SingletonA();
    //私有化構造器
    private SingletonA(){}
    //返回單例對象
    public static SingletonA getInstance()
    {
        return instance;
    }
}

2.懶漢式

懶漢式(Lazy mode)公有的成員是個靜態工廠方法，在調用取得實例方法的時候纔會實例化對象
懶漢第1式：

//Singleton with Lazy mode
public class SingletonB
{
    private static instance;
    private SingletonB(){}
    public static SingletonB getInstance()
    {
        if(instance == null)
            instance = new SingletonB();
        return instance;
    }
}

如果線程1進入了if語句，但還未實例化instance，此時，線程2訪問到getInstance的if判斷，因爲instance還未實例化，所以也進入if內部；於是線程1和線程2，最後創建了兩個實例。

懶漢第2式：同步鎖

public static synchronized SingletonB getInstance()
{
    if(instance == null)
       instance = new SingletonB();
    return instance;
}

可以有效防止多線程在執行getInstance方法得到2個對象，但是：

只有在instance爲null時，才必須要求同步。一旦singleton不爲null，系統依舊花費同步鎖開銷

懶漢第3式：

public static SingletonB getInstance()
{

    if(instance == null)//1
        synchronized(SingletonB.class)//2
        {
            instance = new SingletonB();//3
        }
        return instance;
}

這種寫法減少了鎖開銷，但是依舊可能創建了2個對象。

線程1執行到1掛起，線程1認爲singleton爲null
線程2執行到1掛起，線程2認爲singleton爲null
線程1被喚醒執行synchronized塊代碼，走完創建了一個對象
線程2被喚醒執行synchronized塊代碼，走完創建了另一個對象

懶漢第4式：雙重鎖定檢查（DCL）

public static SingletonB getInstance()
{

    if(instance == null)//1
        synchronized(SingletonB.class)//2
        {
            if(instance == null)
            {
                instance = new SingletonB();//3
            }
        }
        return instance;
}

看是沒有問題，但在instance = new SingletonB()這句中，卻暗藏殺機，因爲jvm在執行這句代碼時，實際分爲三步：開闢內存空間，賦值給引用，初始化數據。這是需要消耗時間。

懶漢最終式：volatile

volatile修飾的成員變量在每次被線程訪問時，都強迫從共享內存中重讀該成員變量的值。

//Singleton with Lazy mode
public class SingletonB
{
    private static volatile instance;
    private SingletonB(){}
    public static SingletonB getInstance()
    {
        if(instance == null)//1
        synchronized(SingletonB.class)//2
        {
            if(instance == null)
            {
                instance = new SingletonB();//3
            }
        }
        return instance;
    }
}

volatile變量具有synchronized 的可見性特性，但是不具備原子特性。這就是說線程能夠自動發現volatile變量的最新值

3.Lazy initialization holder class模式(靜態內部類加載方式)

根據JLS(Java Language Specification)中的規定，一個類在一個ClassLoader中只會被初始化一次，這點是JVM本身保證的

public class SingletonC
{
    private static instance;
    //私有化構造器
    private SingletonC(){}
    //返回單例對象
    public static SingletonC getInstance()
    {
        return SingletonHolder.INSTANCE;
    }
    private static class SingletonHolder
    {
        //單例對象實例
        static final SingletonC INSTANCE = new SingletonC();     
    }  
}

這種寫法仍然使用JVM本身機制保證線程安全問題
由於SingletonHolder是私有的，除了getInstance()之外沒有辦法訪問它，因此它是懶漢式的
同時讀取實例的時候不會進行同步，沒有性能缺陷
也不依賴JDK版本
從其他途徑屏蔽構造單例對象的方法
直接new單例對象
一般加入一個private或者protected的構造函數

4.通過反射構造單例對象

需要在ReflectPermission(“suppressAccessChecks”) 權限下使用安全管理器（SecurityManager）的checkPermission方法來限制這種突破。 一般來說，不會真的去做這些事情，都是通過應用服務器進行後臺配置實現

5.通過序列化構造單例對象

單例對象有必要實現Serializable接口，則應當同時實現readResolve()方法，以保證反序列化的時候得到原來的對象

public class Singleton implements Serializable 
{
    private static class SingletonHolder
    {
        static final Singleton INSTANCE = new Singleton();     
    }     
    public static Singleton getInstance()
    {     
        return SingletonHolder.INSTANCE; 
    }
    //private的構造函數用於避免外界直接使用new來實例化對象  
    private Singleton() {     
    }     
    //readResolve方法應對單例對象被序列化   
    private Object readResolve() {     
        return getInstance();     
    }     
}  

6.單例與枚舉

按照《Effective Java 第二版》中的說法：單元素的枚舉類型已經成爲實現Singleton的最佳方法。用枚舉來實現單例非常簡單，只需要編寫一個包含單個元素的枚舉類型即可。

public enum SingletonEnum
{
    INSTANCE;
    private String field;
    public String getField()
    {
        return field;
    }
    public void setField(String field)
    {
        this.field = field;
    }
    @Override
    public String toString()
    {
        return "SingletonEnum{" +
            "field='" + field + '\'' +
            '}';
    }
}

自由序列化
保證只有一個實例(使用反射機制也無法多次實例化一個枚舉量)
使用單元素的枚舉類型實現Singleton時，通過反射機制去創建新的實例時會拋出異常。

Singleton Mode總結

優點

在內存中只有一個對象，節省內存空間
避免頻繁的創建銷燬對象，可以提高性能
避免對共享資源的多重佔用
可以全局訪問

適用場景

需要頻繁實例化然後銷燬的對象
創建對象時耗時過多或者耗資源過多，但又經常用到的對象。
有狀態的工具類對象。
頻繁訪問數據庫或文件的對象。