單例模式

定義：確保一個類只有一個實例，而且自行實例化並向整個系統提供這個實例。

類型：創建類模式

類圖：

類圖知識點：

1.類圖分為三部分，依次是類名、屬性、方法

2.以<<開頭和以>>結尾的為注釋信息

3.修飾符+代表public，-代表private，#代表protected，什么都沒有代表包可見。

4.帶下划線的屬性或方法代表是靜態的。

單例模式應該是23種設計模式中最簡單的一種模式了。它有以下幾個要素：

• 私有的構造方法
• 指向自己實例的私有靜態引用
• 以自己實例為返回值的靜態的公有的方法

單例模式根據實例化對象時機的不同分為兩種：一種是懶漢式單例，一種是餓漢式單例。餓漢式單例在單例類被加載時候，就實例化一個對象交給自己的引用；而懶漢式在調用取得實例方法的時候才會實例化對象。代碼如下：

懶漢式單例

package com.tfj.pattern;

/**
 * 懶漢式單例類，在第一次調用時實例化自己
 * 
 * @author Jacksile
 */
public class Singleton {
    private static Singleton singleton = null;

    private Singleton() {
    }

    // 靜態實例方法
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

Singleton通過將構造方法限定為private避免了類在外部被實例化（事實上，通過Java反射機制是能夠實例化構造方法為private的類的，那基本上會使所有的Java單例實現失效，這里不考慮反射機制的存在），在同一個虛擬機范圍內，Singleton的唯一實例只能通過getInstance()方法訪問。

但是以上懶漢式單例的實現沒有考慮線程安全問題，它是線程不安全的，並發環境下很可能出現多個Singleton實例，要實現線程安全，有以下三種方式，都是對getInstance這個方法改造，保證了懶漢式單例的線程安全，如果你第一次接觸單例模式，對線程安全不是很了解，可以先跳過下面這三小條，去看餓漢式單例，等看完后面再回頭考慮線程安全的問題：

在getInstance方法上加同步

public static synchronized Singleton getInstance(){
        
    }

雙重檢查鎖定

public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

靜態內部類

package com.tfj.pattern;

public class Singleton {
    private static class LazyStyle {
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton() {
    }

    public static final Singleton getInstance() {
        return LazyStyle.INSTANCE;
    }
}

這種比上面1、2都好一些，既實現了線程安全，又避免了同步帶來的性能影響。

餓漢式單例

package com.tfj.pattern;

/**
 * 餓漢式單例類，在類初始化時，已經自行實例化
 * 
 * @author Jacksile
 */
public class Singleton {
    private static final Singleton singleton = new Singleton();

    private Singleton() {
    }

    // 靜態工廠方法
    public static Singleton getInstance() {
        return singleton;
    }
}

餓漢式在類創建的同時就已經創建好一個靜態的對象供系統使用，以后不再改變，所以天生是線程安全的。

登記式單例(可忽略)

package com.tfj.pattern;

import java.util.HashMap;
import java.util.Map;

/**
 * 類似Spring里面的方法，將類名注冊，下次從里面直接獲取。
 * 
 * @author Jacksile
 */
public class Singleton {
    private static Map<String, Singleton> map = new HashMap<String, Singleton>();
    static {
        Singleton singleton = new Singleton();
        map.put(singleton.getClass().getName(), singleton);
    }

    // 保護的默認構造子
    protected Singleton() {
    }

    // 靜態工廠方法,返還此類惟一的實例
    public static Singleton getInstance(String name) {
        if (name == null) {
            name = Singleton.class.getName();
            System.out.println("name == null" + "--->name=" + name);
        }
        if (map.get(name) == null) {
            try {
                map.put(name, (Singleton) Class.forName(name).newInstance());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return map.get(name);
    }

    // 一個示意性的商業方法
    public String about() {
        return "Hello, I am RegSingleton.";
    }

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance(null);
        System.out.println(singleton.about());
    }
}

記式單例實際上維護了一組單例類的實例，將這些實例存放在一個Map（登記薄）中，對於已經登記過的實例，則從Map直接返回，對於沒有登記的，則先登記，然后返回。
這里我對登記式單例標記了可忽略，我的理解來說，首先它用的比較少，另外其實內部實現還是用的餓漢式單例，因為其中的static方法塊，它的單例在類被裝載的時候就被實例化了。

餓漢式和懶漢式區別

從名字上來說，餓漢和懶漢，
餓漢就是類一旦加載，就把單例初始化完成，保證getInstance的時候，單例是已經存在的了，而懶漢比較懶，只有當調用getInstance的時候，才回去初始化這個單例。

另外從以下兩點再區分以下這兩種方式：

線程安全：

餓漢式天生就是線程安全的，可以直接用於多線程而不會出現問題，懶漢式本身是非線程安全的，為了實現線程安全有幾種寫法，分別是上面的1、2、3，這三種實現在資源加載和性能方面有些區別。

資源加載和性能：

餓漢式在類創建的同時就實例化一個靜態對象出來，不管之后會不會使用這個單例，都會占據一定的內存，但是相應的，在第一次調用時速度也會更快，因為其資源已經初始化完成，
而懶漢式顧名思義，會延遲加載，在第一次使用該單例的時候才會實例化對象出來，第一次調用時要做初始化，如果要做的工作比較多，性能上會有些延遲，之后就和餓漢式一樣了。

至於1、2、3這三種實現又有些區別，

第1種，在方法調用上加了同步，雖然線程安全了，但是每次都要同步，會影響性能，畢竟99%的情況下是不需要同步的，
第2種，在getInstance中做了兩次null檢查，確保了只有第一次調用單例的時候才會做同步，這樣也是線程安全的，同時避免了每次都同步的性能損耗
第3種，利用了classloader的機制來保證初始化instance時只有一個線程，所以也是線程安全的，同時沒有性能損耗，所以一般我傾向於使用這一種。

什么是線程安全？

如果你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結果和單線程運行的結果是一樣的，而且其他的變量的值也和預期的是一樣的，就是線程安全的。
或者說：一個類或者程序所提供的接口對於線程來說是原子操作，或者多個線程之間的切換不會導致該接口的執行結果存在二義性,也就是說我們不用考慮同步的問題，那就是線程安全的。

應用

以下是一個單例類使用的例子，以懶漢式為例，這里為了保證線程安全，使用了雙重檢查鎖定的方式：

package com.tfj.pattern;

/**
 * @author Jacksile
 */
public class TestSingleton {
    String name = null;

    private TestSingleton() {
    }

    private static volatile TestSingleton instance = null;

    public static TestSingleton getInstance() {
        if (instance == null) {
            synchronized (TestSingleton.class) {
                if (instance == null) {
                    instance = new TestSingleton();
                }
            }
        }
        return instance;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void printInfo() {
        System.out.println("The name is " + name);
    }

}

可以看到里面加了volatile關鍵字來聲明單例對象，既然synchronized已經起到了多線程下原子性、有序性、可見性的作用，為什么還要加volatile呢，原因在於方便編寫多線程程序和利於編譯器進行優化。

package com.tfj.pattern;

/**
 * @author Jacksile
 */
public class TMain {
    public static void main(String[] args) {
        TestSingleton ts1 = TestSingleton.getInstance();
        ts1.setName("jason");
        TestSingleton ts2 = TestSingleton.getInstance();
        ts2.setName("0539");

        ts1.printInfo();
        ts2.printInfo();

        if (ts1 == ts2) {
            System.out.println("創建的是同一個實例");
        } else {
            System.out.println("創建的不是同一個實例");
        }
    }
}

單例模式的優點：

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

適用場景：

由於單例模式的以上優點，所以是編程中用的比較多的一種設計模式。我總結了一下我所知道的適合使用單例模式的場景：

• 需要頻繁實例化然后銷毀的對象。
• 創建對象時耗時過多或者耗資源過多，但又經常用到的對象。
• 有狀態的工具類對象。
• 頻繁訪問數據庫或文件的對象。
• 以及其他我沒用過的所有要求只有一個對象的場景。

單例模式注意事項：

• 只能使用單例類提供的方法得到單例對象，不要使用反射，否則將會實例化一個新對象。
• 不要做斷開單例類對象與類中靜態引用的危險操作。
• 多線程使用單例使用共享資源時，注意線程安全問題。

關於Java中單例模式的一些爭議：

單例模式的對象長時間不用會被jvm垃圾收集器收集嗎

看到不少資料中說：如果一個單例對象在內存中長久不用，會被jvm認為是一個垃圾，在執行垃圾收集的時候會被清理掉。對此這個說法，筆者持懷疑態度，筆者本人的觀點是：在hotspot虛擬機1.6版本中，除非人為地斷開單例中靜態引用到單例對象的聯接，否則jvm垃圾收集器是不會回收單例對象的。

在一個jvm中會出現多個單例嗎

在分布式系統、多個類加載器、以及序列化的的情況下，會產生多個單例，這一點是無庸置疑的。那么在同一個jvm中，會不會產生單例呢？使用單例提供的getInstance()方法只能得到同一個單例，除非是使用反射方式，將會得到新的單例。代碼如下

Class c = Class.forName(Singleton.class.getName());  
Constructor ct = c.getDeclaredConstructor(); ct.setAccessible(true); Singleton singleton = (Singleton)ct.newInstance();

這樣，每次運行都會產生新的單例對象。所以運用單例模式時，一定注意不要使用反射產生新的單例對象。

懶漢式單例線程安全嗎

主要是網上的一些說法，懶漢式的單例模式是線程不安全的，即使是在實例化對象的方法上加synchronized關鍵字，也依然是危險的，但是筆者經過編碼測試，發現加synchronized關鍵字修飾后，雖然對性能有部分影響，但是卻是線程安全的，並不會產生實例化多個對象的情況。

單例模式只有餓漢式和懶漢式兩種嗎

餓漢式單例和懶漢式單例只是兩種比較主流和常用的單例模式方法，從理論上講，任何可以實現一個類只有一個實例的設計模式，都可以稱為單例模式。

單例類可以被繼承嗎

餓漢式單例和懶漢式單例由於構造方法是private的，所以他們都是不可繼承的，但是其他很多單例模式是可以繼承的，例如登記式單例。

餓漢式單例好還是懶漢式單例好

在Java中，餓漢式單例要優於懶漢式單例。C++中則一般使用懶漢式單例。

結論：

由結果可以得知單例模式為一個面向對象的應用程序提供了對象惟一的訪問點，不管它實現何種功能，整個應用程序都會同享一個實例對象。對於單例模式的幾種實現方式，知道餓漢式和懶漢式的區別，線程安全，資源加載的時機，還有懶漢式為了實現線程安全的3種方式的細微差別。