JAVA設計模式之單例模式（單件模式）—Singleton Pattern

1.什么是單例模式？

《Head First 設計模式》中給出如下定義：確保一個類只有一個實例，並提供一個全局訪問點。

關鍵詞：唯一實例對象。

 

2.單例模式的實現方式：

2.1 懶漢式

 對於實例做懶加載處理，即在客戶第一次使用時再做創建，所以第一次獲取實例的效率會稍微低一些。

/**
 * 懶漢式
 * @author Lsj
 */
public class LazySingleton {
    
    private static LazySingleton instance;
    
    /**
     * 獲取單一實例對象—非同步方法
     * @return
     */
    public static LazySingleton getInstance(){
        if(instance == null){
            try {
                TimeUnit.NANOSECONDS.sleep(1);//為了使模擬效果更直觀，這里延時1ms，具體看時序圖
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            instance = new LazySingleton();
        }
        return instance;
    }
    
}

這種創建方式可以延遲加載、但是在多線程環境下獲取到的實例可能並非唯一的，具體見如下驗證：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * 懶漢式
 * @author Lsj
 */
public class LazySingleton {
    
    private static LazySingleton instance;
    
    /**
     * 獲取單一實例對象—非同步方法
     * @return
     */
    public static LazySingleton getInstance(){
        if(instance == null){
            try {
                TimeUnit.NANOSECONDS.sleep(1);//為了使模擬效果更直觀，這里延時1ms，具體看時序圖
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            instance = new LazySingleton();
        }
        return instance;
    }
    
    /**
     * 增加同步鎖
     * 避免多線程環境下並發產生多個實例可能的同時，會帶來性能上的損耗。
     * 事實上只有第一次創建時需要這么做，但后續依然通過加鎖獲取單例對象就有點因小失大了。
     * @return
     */
    public synchronized static LazySingleton getInstanceSyn(){
        if(instance == null){
            try {
                TimeUnit.MILLISECONDS.sleep(1);//為了使模擬效果更直觀，這里延時1ms，具體看時序圖
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            instance = new LazySingleton();
        }
        return instance;
    }
    
    public static void main(String[] args) throws InterruptedException {
        //模擬下多線程環境下實例可能不唯一的情況
        CountDownLatch startSignal = new CountDownLatch(1);
        for(int i=0;i<2;i++){//模擬2個線程  
            Thread t = new Thread(new MyThread(startSignal));
            t.setName("thread " + i);
            t.start();  
        }  
        Thread.sleep(1000);
        startSignal.countDown();
    }

}

class MyThread implements Runnable {
    
    private final CountDownLatch startSignal;

    public MyThread(CountDownLatch startSignal){
        this.startSignal = startSignal;
    }

    public void run() {
        try {
            System.out.println("current thread : " + Thread.currentThread().getName() + " is waiting.");
            startSignal.await();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        LazySingleton l = LazySingleton.getInstance();
        System.out.println(l);
    }
    
}

從驗證結果可以看出兩個線程同時獲取實例時，得到的並非同一個實例對象：

 

2.2 懶漢式（+同步鎖）

public synchronized static LazySingleton getInstanceSyn(){
    if(instance == null){
         instance = new LazySingleton();
    }
    return instance;
}

在上述懶漢式的獲取對象方法上做出一些改變，給獲取實例的方法加上synchronized同步鎖， 但是這種做法在多次調用獲取實例方法的情況下會帶來性能上的損耗。

事實上只有第一次創建實例時需要這么做，但后續依然通過加鎖獲取單例對象就有點因小失大了。

 

2.3 餓漢式

顧名思義、在類加載時就將唯一實例一並加載，后續只需要獲取就可以了。

/**
 * 餓漢式
 * @author Lsj
 */
public class HungrySingleton {

    private static final String CLASS_NAME = "HungrySingleton";
    
    private static final HungrySingleton instance = new HungrySingleton();

    static{
        System.out.println("類加載時創建:"+instance);//這里可以看到類加載后，優先加載上方的靜態成員變量
    }
    
    private HungrySingleton(){
        
    }
    
    public static HungrySingleton getInstance(){
        return instance;
    }

    public static void main(String[] args) throws ClassNotFoundException {
        System.out.println(HungrySingleton.CLASS_NAME);//可以看到，這里僅僅是打印HungrySingleton的靜態常量，但實例依然被初始化了。
        System.out.println("==========分割線==========");
        HungrySingleton instance1 = HungrySingleton.getInstance();
        System.out.println(instance1);
        HungrySingleton instance2 = HungrySingleton.getInstance();
        System.out.println(instance2);
    }
    
}

運行結果：

從結果可以看到，這種獲取單例的方式是線程安全的，JVM保障在多線程情況下一定先創建此實例並且只做一次實例化處理，但是這種情況沒有做到懶加載，比如只是引用此類中的一個靜態成員變量(常量)，此實例在類加載時也一起被初始化了，如果后續應用中不使用這個對象，則會造成資源浪費，占用內存。

 

2.4 雙重檢查加鎖

此方式可以看做是在懶漢式（+同步鎖）方式上的進一步提升，從代碼上可以看出主要是針對創建的過程加同步鎖。

 

/**
 * 通過雙重檢查的方式創建及獲取單例對象
 * @author Lsj
 */
public class DoubleCheckedLockingSingleton {
    
    private volatile static DoubleCheckedLockingSingleton instance;
    
    private DoubleCheckedLockingSingleton(){}
    
    public static DoubleCheckedLockingSingleton getInstance(){
        if(instance == null){
            synchronized (DoubleCheckedLockingSingleton.class) {
                if(instance == null){
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }

}

 

這種方式可以大大減少2.2方法中獲取實例時不必要的同步操作，需要注意的是：靜態成員變量中定義的volatile關鍵字，保證線程間變量的可見性以及防止指令重排序，同時需要的注意必須是jdk1.5及以上版本（volatile關鍵字在1.5做出了增強處理）。

--這里后續補充不加volatile關鍵字的危害。

 

2.5 靜態內部類

此方案是基於類初始化的解決方案，JVM在類的初始化階段，會執行類的初始化。在執行類的初始化期間，JVM會去獲取一個鎖。這個鎖可以同步多個線程對同一個類的初始化。

/**
 * 以靜態內部類的方式來創建獲取單例對象
 * @author Lsj
 *
 */
public class InnerSingleton {

    private InnerSingleton(){
    }
    
    public static InnerSingleton getInstance(){
        return InnerSingleton.InnerClass.instance;
    }
    
    static class InnerClass {
        private static InnerSingleton instance = new InnerSingleton();
    }
    
}

這種方式受益於JVM在多線程環境下對於類初始化的同步控制，這里不再做太詳細的說明。

 

2.6 通過枚舉實現單例

《Effective Java》一書中作者Joshua Bloch提倡使用這種方式，這種方式依然是依靠JVM保障，而且可以防止反序列化的時候創建新的對象。

/**
 * 通過枚舉實現單例模式
 * @author Lsj
 *
 */
public class EnumSingleton {

    public static EnumSingleton getInstance(){
        return Singleton.INSTANCE.getInstance();
    }
    
    enum Singleton {
        INSTANCE;
        private EnumSingleton instance;
        
        private Singleton(){
            instance = new EnumSingleton();
        }
        
        private EnumSingleton getInstance(){
            return instance;
        }
    }
    
}

筆者沒有這么使用過，暫不做過多描述、實際工作中也很少看到有這么用的，待后續有深入了解后再補充。

 

3. 總結：

幾種單例模式的實現方式中，建議使用4,5,6這三種方式，實際根據使用場景作出選擇，另外對於上述提到的幾種方式1~5，需要防范通過反射或反序列化的手段創建對象從而使得實例不再唯一，筆者也會在后續會對此作出補充。

 

參考文獻：

《Head Frist設計模式》

《Effective Java》

《Java並發編程的藝術》