在介紹單例模式之前，我們先了解一下，什麼是設計模式？
設計模式（Design Pattern）：是一套被反覆使用，多數人知曉的，經過分類編目的，代碼設計經驗的總結。
目的：使用設計模式是爲了可重用性代碼，讓代碼更容易被他人理解，保證代碼可靠性。
單例模式：
單例，顧名思義就是只能有一個、不能再出現第二個。就如同地球上沒有兩片一模一樣的樹葉一樣。
在這裏就是說：一個類只能有一個實例，並且整個項目系統都能訪問該實例。
單例模式共分爲兩大類：
懶漢模式：實例在第一次使用時創建
餓漢模式：實例在類裝載時創建
餓漢模式
按照定義我們可以寫出一個基本代碼：
public class Singleton {
// 使用private將構造方法私有化，以防外界通過該構造方法創建多個實例
private Singleton() {
}
// 由於不能使用構造方法創建實例，所以需要在類的內部創建該類的唯一實例
// 使用static修飾singleton 在外界可以通過類名調用該實例 類名.成員名
static Singleton singleton = new Singleton(); //1
// 如果使用private封裝該實例，則需要添加get方法實現對外界的開放
private static Singleton instance = new Singleton(); // 2
// 添加static，將該方法變成類所有 通過類名訪問
public static Singleton getInstance(){
return instance;
}
//1和2選一種即可，推薦2
}對於餓漢模式來說，這種寫法已經很‘perfect’了，唯一的缺點就是，由於instance的初始化是在類加載時進行的，類加載是由ClassLoader來實現的，如果初始化太早，就會造成資源浪費。
當然，如果所需的單例佔用的資源很少，並且也不依賴於其他數據，那麼這種實現方式也是很好的。
類裝載的時機：
new一個對象時
使用反射創建它的實例時
子類被加載時，如果父類還沒有加載，就先加載父類
JVM啓動時執行主類，會先被加載
懶漢模式
懶漢模式的代碼如下
// 代碼一
public class Singleton {
private static Singleton instance = null;
private Singleton(){
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}每次獲取instance之前先進行判斷，如果instance爲空就new一個出來，否則就直接返回已存在的instance。
這種寫法在單線程的時候是沒問題的。但是，當有多個線程一起工作的時候，如果有兩個線程同時運行到 if (instance == null)，都判斷爲null（第一個線程判斷爲空之後，並沒有繼續向下執行，當第二個線程判斷的時候instance依然爲空），最終兩個線程就各自會創建一個實例出來。這樣就破環了單例模式 實例的唯一性，要想保證實例的唯一性就需要使用synchronized，加上一個同步鎖：
// 代碼二
public class Singleton {
private static Singleton instance = null;
private Singleton() {}
public static Singleton getInstance() {
synchronized(Singleton.class){
if (instance == null)
instance = new Singleton();
}
return instance;
}
}
加上synchronized關鍵字之後，getInstance方法就會鎖上了。如果有兩個線程（T1、T2）同時執行到這個方法時，會有其中一個線程T1獲得同步鎖，得以繼續執行，而另一個線程T2則需要等待，當第T1執行完畢getInstance之後（完成了null判斷、對象創建、獲得返回值之後），T2線程纔會執行執行。
所以這段代碼也就避免了代碼一中，可能出現因爲多線程導致多個實例的情況。但是，這種寫法也有一個問題：給getInstance方法加鎖，雖然避免了可能會出現的多個實例問題，但是會強制除T1之外的所有線程等待，實際上會對程序的執行效率造成負面影響。
雙重檢查（Double-Check）
代碼二相對於代碼一的效率問題，其實是爲了解決1%機率的問題，而使用了一個100%出現的防護盾。那有一個優化的思路，就是把100%出現的防護盾，也改爲1%的機率出現，使之只出現在可能會導致多個實例出現的地方。
代碼如下：
// 代碼三
public class Singleton {
private static Singleton instance = null;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null){
synchronized(Singleton.class){
if (instance == null)
instance = new Singleton();
}
}
return instance;
}
}這段代碼看起來有點複雜，注意其中有兩次if(instance==null)的判斷，這個叫做『雙重檢查 Double-Check』。
第一個 if(instance==null)，其實是爲了解決代碼二中的效率問題，只有instance爲null的時候，才進入synchronized的代碼段大大減少了機率。
這段代碼看起來已經完美無瑕了。當然，只是『看起來』，還是有小概率出現問題的。想要充分理解需要先弄清楚以下幾個概念：原子操作、指令重排。
原子操作
簡單來說，原子操作（atomic）就是不可分割的操作，在計算機中，就是指不會因爲線程調度被打斷的操作。比如，簡單的賦值是一個原子操作：
m = 6; // 這是個原子操作假如m原先的值爲0，那麼對於這個操作，要麼執行成功m變成了6，要麼是沒執行 m還是0，而不會出現諸如m=3這種中間態——即使是在併發的線程中。
但是，聲明並賦值就不是一個原子操作：
int n=6;//這不是一個原子操作對於這個語句，至少有兩個操作：①聲明一個變量n ②給n賦值爲6——這樣就會有一箇中間狀態：變量n已經被聲明瞭但是還沒有被賦值的狀態。這樣，在多線程中，由於線程執行順序的不確定性，如果兩個線程都使用m，就可能會導致不穩定的結果出現。
指令重排
簡單來說，就是計算機爲了提高執行效率，會做的一些優化，在不影響最終結果的情況下，可能會對一些語句的執行順序進行調整。比如，這一段代碼：
int a ; // 語句1
a = 8 ; // 語句2
int b = 9 ; // 語句3
int c = a + b ; // 語句4正常來說，對於順序結構，執行的順序是自上到下，也即1234。但是，由於指令重排的原因，因爲不影響最終的結果，所以，實際執行的順序可能會變成3124或者1324。由於語句3和4沒有原子性的問題，語句3和語句4也可能會拆分成原子操作，再重排。——也就是說，對於非原子性的操作，在不影響最終結果的情況下，其拆分成的原子操作可能會被重新排列執行順序。
OK，瞭解了原子操作和指令重排的概念之後，我們再繼續看代碼三的問題。
主要在於singleton = new Singleton()不是一個原子操作，事實上在 JVM 中這句話大概做了下面 3 件事情。
1. 給 singleton 分配內存
2. 調用 Singleton 的構造函數來初始化成員變量，形成實例
3. 將singleton對象指向分配的內存空間（執行完這步 singleton纔是非 null了）
而在JVM的即時編譯器中存在指令重排序的優化。
也就是說上面的第二步和第三步的順序是不能保證的，最終的執行順序可能是 1-2-3 也可能是 1-3-2。如果是後者，則在 3 執行完畢、2 未執行之前，也就是說，由於有一個『instance已經不爲null但是仍沒有完成初始化』的中間狀態，而這個時候，如果有其他線程剛好運行到第一層if (instance ==null)這裏，這裏讀取到的instance已經不爲null了，所以就直接把這個中間狀態的instance拿去用了，就會產生問題。這裏的關鍵在於線程T1對instance的寫操作沒有完成，線程T2就執行了讀操作。
對於代碼三出現的問題，解決方案爲：給instance的聲明加上volatile關鍵字
代碼如下：
public class Singleton {
private static volatile Singleton instance = null;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null){
synchronized(Singleton.class){
if (instance == null)
instance = new Singleton();
}
}
return instance;
}
}volatile關鍵字的一個作用是禁止指令重排，把instance聲明爲volatile之後，對它的寫操作就會有一個內存屏障，這樣，在它的賦值完成之前，就不用會調用讀操作。
注意：volatile阻止的不是singleton = new Singleton()這句話內部[1-2-3]的指令重排，而是保證了在一個寫操作（[1-2-3]）完成之前，不會調用讀操作（if (instance == null)）。
其它方法：
靜態內部類
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}這種寫法的巧妙之處在於：對於內部類SingletonHolder，它是一個餓漢式的單例實現，在SingletonHolder初始化的時候會由ClassLoader來保證同步，使INSTANCE是一個真單例。同時，由於SingletonHolder是一個內部類，只在外部類的Singleton的getInstance()中被使用，所以它被加載的時機也就是在getInstance()方法第一次被調用的時候。
它利用了ClassLoader來保證了同步，同時又能讓開發者控制類加載的時機。從內部看是一個餓漢式的單例，但是從外部看來，又的確是懶漢式的實現