【單例模式】
一、特點：
1.單例類只能有一個實例2.單例類必須自己創建自己的唯一實例
3.單例類必須給所有其他對象提供這一實例
單例模式確保某個類只有一個實例，而且自行實例化並向整個系統提供這個實例
二、分類
（一）、懶漢式單例
//懶漢式單例類，在第一次調用的時候實例化自己public class Singleton{
//構造方法私有化
private Singleton(){}
private static Singleton single = null;
//靜態工廠方法
public static Singleton getInstance(){
if(single == null){
single = new Singleton();
}
return single;
}
}
Singleton通過將構造方法限定爲private避免了類在外部被實例化，在同一個虛擬機範圍內，Singleton的唯一實例只能通過getInstance()方法訪問。
（事實上，通過JAVA反射機制是能夠實例化構造方法爲private的類的，那基本上會使所有的Java單例實現失效。）
但是以上懶漢式單例的實現沒有考慮線程安全問題，它是線程不安全的。併發環境下很可能出現多個Singleton實例，要實現線程安全，有以下三種方式。都是對getInstance方法改造，保證了懶漢式單例的線程安全。
1、在getInstance方法上加同步
public static synchronized Singleton getInstance(){
if(single == null){
single = new Singleton();
}
return single;
}
2、雙重檢查鎖定
所謂“雙重檢查加鎖”機制，指的是：並不是每次進入getInstance方法都需要同步，而是先不同步，進入方法後，先檢查實例是否存在，如果不存在才進行下面的同步塊，這是第一重檢查，進入同步塊後，再次檢查實例是否存在，如果不存在，就在同步的情況下創建一個實例，這是第二重檢查。這樣一來，就只需要同步一次了，從而減少了多次在同步情況下進行判斷所浪費的時間。
“雙重檢查加鎖”機制的實現會使用關鍵字volatile，它的意思是：被volatile修飾的變量的值，將不會被本地線程緩存，所有對該變量的讀寫都是直接操作共享內存，從而確保多個線程能正確的處理該變量。
注意：在java4及之前版本中，很多JVM對於volatile關鍵字的實現問題，會導致雙重檢查加鎖的失敗，因此雙重檢查加鎖機制只能用在java5及以上的版本。
public class Singleton{
private volatile static Singleton instance =null;
private Singleton(){}
private static Singleton getInstance(){
//先判斷實例是否存在，如果不存在才進入同步塊
if(instance == null){
//同步塊，線程安全的創建實例
synchronized(Singleton.class){
//再次檢查實例是否存在，如果不存在才真正的創建實例
if(instance==null){
instance = new Singleton();
}
}
}
return instance;
}
}
這種實現方式既可以線程安全的創建實例，而又不會對性能造成太大的影響。它只是第一次創建實例的時候同步，以後就不需要同步了，從而加快了運行速度。
（摘自網絡）提示：由於volatile關鍵字可能會屏蔽掉虛擬機中一些必要的代碼優化，所以運行效率並不搞。因此一般建議，沒有特別的需要，不要使用。也就是說，雖然可以使用“雙重檢查加鎖”機制來實現線程安全的單例，但不建議大量採用。根據情況選用。
3.靜態（類級）內部類
public class Singleton{
private Singleton(){}
//類級的內部類 也就是靜態的成員式內部類，該內部類的實例與外部類的實例
//沒有綁定關係，而且只有被調用到時纔會裝載，從而實現了延遲加載。
private static class SingletonHolder{
private static Singleton instance = new Singleton();
}
//靜態初始化器，，由JVM來保證線程安全
public static Singleton getInstance(){
return SingletonHolder.instance;
}
}
這種比上面1、2都好一些，既實現了線程安全，又避免了同步帶來的性能影響。當getInstance方法第一次被調用時，它第一次讀取SingletonHolder.instance,導致SingletonHolder類得到初始化;而這個類在裝載並被初始化的時候，會初始化它的靜態域，從而創建Singleton的實例。由於是靜態的域，只會在虛擬機裝載類的時候初始化一次，並由虛擬機來保證它的線程安全性。
這個模式的優勢來於，getInstance方法並沒有被同步，並且至少執行一個域的訪問，因此延遲初始化並沒有增加任何訪問成本。
這三種實現有些區別：
第一種，在方法上加了同步，雖然線程安全了，但每次都要同步，會影響性能。
第二種，在getInstance中做了兩次null檢查，確保只有第一次調用單例的時候纔會做同步，這樣是線程安全的，同時避免了每次都同步的性能損耗。
第三種，保證初始化instance時只有一個線程，所以是線程安全的，同時沒有性能損耗，一般傾向於這一種。
（二）、餓漢式單例
//餓漢式單例類，在類初始化時，已經自行實例化
public class EagerSingleton{
private static EagerSingleton instance = new EagerSingleton();
//構造方法私有化
private EagerSingleton();
//靜態工廠方法
public static EagerSingleton getInstance(){
return instance;
}
}
餓漢式在類創建的同時就已經創建好一個靜態的對象供系統使用，以後不再改變，所以天生是線程安全的
（三）、單例和枚舉
用枚舉來實現單例非常簡單，只需要編寫一個包含單個元素的枚舉類型即可
public enum Singleton{
//定義一個枚舉的元素，它就代表了Singleton的一個實例
uniqueInstance;
//單例可以有自己的操作
public void singtonOperation;
}
相關測試代碼：
public enum SingletonEnum {
INSTANCE01, INSTANCE02;// 定義枚舉的兩個類型
private String name;
public String getName() {
return name;
}
public void setName(String name){
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
SingletonEnum instance01=SingletonEnum.INSTANCE01;
instance01.setName("tanggao");
System.out.println(instance01.getName());
SingletonEnum instance02=SingletonEnum.INSTANCE01;
System.out.println(instance02.getName());
SingletonEnum instance03=SingletonEnum.INSTANCE02;
instance03.setName("zsy");
System.out.println(instance03.getName());
SingletonEnum instance04=SingletonEnum.INSTANCE02;
instance04.setName("zsy1");
System.out.println(instance04.getName());
System.out.println(instance03.hashCode()+"\t"+instance04.hashCode());
System.out.println(instance03==instance04);
}
}
使用枚舉來實現單例控制會更簡潔，而且無償地提供了序列化機制，並有JVM從根本上提供保障，絕對防止多次實例化，是更簡潔、高效安全的實現方式。
三、餓漢式和懶漢式的區別
餓漢就是類一旦加載，就把單例初始化完成，保證getInstance的時候，單例是已經存在的了，而懶漢比較懶，只有當調用getInstance的時候，纔會去初始化這個單例。另外從以下兩點再區分一下兩者：
1，線程安全：
餓漢式天生就是線程安全的，可以直接用於多線程而不會出現問題。
懶漢式本身是非線程安全的。要通過上述方式實現線程安全。
2，資源加載和性能：
餓漢式在類創建的時候就實例化一個靜態對象出來，之後不管會不會使用這個單例，都會在內存中佔用一定空間。但是相應的，第一次調用速度也更快，因爲其已經初始化完成。
懶漢式會延遲加載，在調用單例時纔會實例化出來，第一次調用要做初始化，性能會有些延遲，之後就和餓漢式一樣了。