java設計模式 - 單例模式（乾貨）

　　深度講解23種設計模式，力爭每種設計模式都刨析到底。廢話很少說，開始第一種設計模式 - 單例。

　　做者已知的單例模式有8種寫法，而每一種寫法，都有自身的優缺點。

1，使用頻率最高的寫法，廢話很少說，直接上代碼

/**
 * @author xujp
 * 餓漢式 靜態變量 單例
 */

public class Singleton  implements Serializable {

    private static final long serialVersionUID = 1L;

    private final static Singleton instance = new Singleton();

    private Singleton(){}
    public static Singleton getSingleton(){
        return instance;
    }

    private String tmp;

    public String getTmp() {
        return tmp;
    }

    public void setTmp(String tmp) {
        this.tmp = tmp;
    }
}

　new Singleton() 的執行時機 - > 類加載時

　這種方法是最通用的單例實現，也是筆者經常使用的，但這種方法有一些缺點：

　1）內存方面，若是單例中的內容不少，會在類加載時，就佔用java虛擬機（這裏專指HotSpot）空間。

　2）序列化以及反序列化問題，若是這個單例類實現了序列化接口Serializable，那麼能夠經過反序列化來破壞單例。

　經過反序列化破壞單例：

public static void main(String[] args) throws IOException, ClassNotFoundException {
    Singleton singleton=null;
    Singleton singletonNew=null;

    singleton=Singleton.getSingleton();

    singleton.setTmp("123");

    ByteArrayOutputStream bos=new ByteArrayOutputStream();
    ObjectOutputStream oos=new ObjectOutputStream(bos);
    oos.writeObject(singleton);

    ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray());
    ObjectInputStream ois=new ObjectInputStream(bis);
    singletonNew= (Singleton) ois.readObject();

    singleton.setTmp("456");

    System.out.println(singletonNew.getTmp());
    System.out.println(singleton.getTmp());
    System.out.println(singleton==singletonNew);
}

　　輸出結果爲：

　　false

　　123

　　456

　　從這裏例子中咱們能夠看到單例被破壞了，也就不能保證單例的惟一性。

2，第一種方案的變種

/**
 * @author xujp
 * 餓漢式 靜態代碼塊 單例
 */
public class Singleton implements Serializable {

    private static final long serialVersionUID = 1L;

    private final static Singleton instance;

    static {
        instance = new Singleton();
    }

    private Singleton(){}

    public static Singleton getSingleton(){
        return instance;
    }
}

　其實這種方法和第一種方法，幾乎沒有什麼區別。

3，線程不安全的寫法 - 1

/**
 * @author xujp
 * 懶漢式 單例 線程不安全
 */
public class Singleton implements Serializable {

    private static final long serialVersionUID = 1L;

    private static Singleton instance;

    private Singleton(){}

    public static Singleton getSingleton(){
        if(null != instance) {
            instance = new Singleton();
        }
        return instance;
    }
}

　這種寫法，雖然實現了懶加載，節省了內存，但線程不安全。

　假設有兩個線程，並假設 new Singleton() 耗時2秒，0秒時，線程1執行new，而後去等待，1秒時，線程2執行if判斷，

這個時候判斷結果就是true，這樣就會出現兩個Singleton對象，完美破壞掉了單例。

4，線程不安全的寫法 - 2

/**
 * @author xujp
 * 懶漢式 單例 代碼塊加鎖 線程不安全
 */
public class Singleton implements Serializable {

    private static final long serialVersionUID = 1L;

    private static Singleton instance;

    private Singleton(){}

    public static Singleton getSingleton(){
        if(null != instance) {
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}

　這種寫法雖然在new Single()時，增長了鎖，但這個鎖，並不能阻止單例被破壞，因此這種寫法錯誤。

　一樣，假設有兩個線程，線程1執行到synchronized時，線程2執行if判斷，這個時候判斷結果就是true，

這樣就會出現兩個Singleton對象，一樣完美破壞掉了單例。

5，線程安全，但資源消耗過多

/**
 * @author xujp
 * 懶漢式 單例 方法加鎖 線程不安全
 */
public class Singleton implements Serializable {

    private static final long serialVersionUID = 1L;

    private static Singleton instance;

    private Singleton(){}

    synchronized public static Singleton getSingleton(){
        if(null != instance) {
            instance = new Singleton();
        }
        return instance;
    }
}

　這種寫法確實可以保證線程安全，但synchronized屬於方法鎖，而方法鎖回鎖定對象，致使性能低下。

6，相對完美的寫法 - 1

/**
 * @author xujp
 * 懶漢式 單例 代碼加鎖 線程安全
 */
public class Singleton implements Serializable {

    private static final long serialVersionUID = 1L;

    private static Singleton instance;

    private Singleton(){}

    public static Singleton getSingleton(){
        if(null != instance) {
            synchronized (Singleton.class) {
                if(null != instance) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

雙檢查這種寫法，在多線程問題上，屬實沒有問題，synchronized也沒有鎖定對象，並且也優化了鎖資源開銷問題。

7，相對完美的寫法 - 2

/**
 * @author xujp
 * 懶漢式 單例 靜態內部類 線程安全
 */
public class Singleton implements Serializable {

    private static final long serialVersionUID = 1L;

    private static class SingletonInstance{
        private static Singleton instance = new Singleton();
    }
    private Singleton(){}

    public static Singleton getSingleton(){
        return SingletonInstance.instance;
    }
}

使用靜態內部類來實現單例，主要藉助JVM機制，靜態內部類初始化的時候，其餘線程沒法進入，從而避免了多線程問題。

並且靜態內部類不會直接初始化，從而減輕了內存開銷。

8，完美寫法

/**
 * @author xujp
 * 枚舉實現單例
 */
public enum Singleton {
    SINGLETON;
    private String property = "hello ca fe ba be";
    public void doSomeThing(){
        System.out.println(property);
    }
}

這種寫法用枚舉解決多線程問題，並且時惟一一種解決序列化問題的寫法。

改寫法出自大神Josh Bloch，若是有興趣能夠去查看一下他的資料。

總結：

1，1和2寫法雖然是餓漢式，沒有實現懶加載，也沒有100%保證單例，但倒是咱們最經常使用的寫法，

　由於，單例對象一般佔用空間不會很大，並且程序都由程序員本身管理，被反序列的危險性不高。

2，3和4寫法實現了懶加載，減小了內存開銷，但不能使用，由於多線程開發，是咱們常見的開發。

3，5寫法使用了方法鎖，會將對象鎖住，會致使性能大打折扣。

4，6和7寫法，懶加載、性能都很是完美，缺點只有一個，那就是序列化問題。

5，8寫法，筆者暫未發現缺點。

實際開發中，不管是使用一、2寫法，仍是使用六、7寫法，亦或是使用8寫法，都是能夠的。