設計模式(創建型)-單例模式

摘要? ? ? ??

????????在軟件開發的世界里，設計模式是開發者們智慧的結晶，它們為解決常見問題提供了經過驗證的通用方案。單例模式作為一種基礎且常用的設計模式，在許多場景中發揮著關鍵作用。本文將深入探討單例模式的定義、實現方式、應用場景以及可能面臨的問題與解決方案。

定義

????????單例模式的核心目標是保證一個類在整個系統中僅有一個實例存在，并且為系統提供一個訪問該實例的全局訪問點。這種模式在資源管理、數據共享等方面具有重要意義。例如，在一個數據庫連接管理系統中，為了避免頻繁創建和銷毀數據庫連接帶來的性能開銷，使用單例模式確保整個應用程序只有一個數據庫連接實例，所有對數據庫的操作都通過這個唯一的連接進行。

類圖

實現方式

餓漢式

????????餓漢式單例在類加載時就立即創建唯一的實例對象。代碼實現如下：

public class HungrySingleton {// 聲明并初始化唯一實例private static final HungrySingleton instance = new HungrySingleton();// 私有構造函數，防止外部實例化private HungrySingleton() {}// 提供全局訪問點public static HungrySingleton getInstance() {return instance;}
}

????????這種方式的優點是線程安全，因為實例在類加載階段就已創建，而類加載過程由 JVM 保證線程安全。同時，調用效率高，因為不需要額外的同步操作。然而，它的缺點是不能延遲加載。如果該單例對象占用資源較大，而在系統運行過程中可能很長時間都不會用到，那么這種提前創建實例的方式會造成資源浪費。

懶漢式

????????懶漢式單例是在第一次調用?getInstance?方法時才創建實例。代碼如下：

public class LazySingleton {// 聲明靜態實例，初始值為nullprivate static volatile LazySingleton instance = null;// 私有構造函數private LazySingleton() {}// 同步的獲取實例方法public static synchronized LazySingleton getInstance() {if (instance == null) {instance = new LazySingleton();}return instance;}
}

????????懶漢式的優勢在于可以延遲加載，只有在真正需要使用實例時才創建，避免了資源的過早占用。但是，由于?getInstance?方法使用了?synchronized?關鍵字進行同步，在多線程環境下，每次調用該方法都需要進行同步操作，這會導致調用效率不高。

雙重檢查鎖式

????雙重檢查鎖模式旨在解決單例、性能和線程安全問題。代碼如下：

public class LazyMan3 {private LazyMan3(){}private static volatile LazyMan3 instance;public static LazyMan3 getInstance(){//第一次判斷,如果instance不為null,不需要搶占鎖，直接返回對象if (instance == null){synchronized (LazyMan3.class){//第二次判斷if (instance == null){instance = new LazyMan3();}}}return instance;}
}
class LazyMan3Test{public static void main(String[] args) {LazyMan3 instance = LazyMan3.getInstance();LazyMan3 instance1 = LazyMan3.getInstance();System.out.println(instance == instance1);}
}

????????這種方式通過兩次?if?判斷，在第一次判斷實例不為?null?時，直接返回實例，避免了同步操作帶來的性能開銷。只有當實例為?null?時，才進入同步塊進行實例創建。然而，在多線程環境下，由于 JVM 會對實例化對象進行優化和指令重排序操作，可能會出現空指針問題。解決這個問題的方法是使用?volatile?關鍵字修飾?instance?變量，volatile?可以保證可見性和有序性，防止指令重排序導致的空指針異常。

靜態內部類式

????????靜態內部類式單例利用了類加載機制來實現線程安全和延遲加載。代碼如下：


public class LazyMan4 {private LazyMan4(){}//定義一個靜態內部類private static class LazyMan4Holder{private static final LazyMan4 INSYANCE = new LazyMan4();}//對外訪問方法public static LazyMan4 getInstance(){return LazyMan4Holder.INSYANCE;}
}
class LazyMan4Test{public static void main(String[] args) {LazyMan4 instance = LazyMan4.getInstance();LazyMan4 instance1 = LazyMan4.getInstance();System.out.println(instance == instance1);}
}

????????當外部類?LazyMan4?被加載時，其靜態內部類?LazyMan4Holder?并不會立即被加載。只有當調用?getInstance?方法時，LazyMan4Holder?才會被加載，此時會創建?LazyMan4?的唯一實例。這種方式保證了線程安全，因為類加載過程是線程安全的。同時，實現了延遲加載，提高了資源的利用效率。不過，與懶漢式類似，其調用效率相對不高。

靜態代碼塊式

????????靜態代碼塊式單例在靜態代碼塊中完成實例的初始化。代碼如下：

public class HungryChinese2 {//私有構造方法，為了不讓外界創建該類的對象private HungryChinese2(){}//聲明該類類型的變量private static HungryChinese2 hungryChinese2;//初始值為null//靜態代碼塊中賦值static {hungryChinese2 = new HungryChinese2();}//對外提供的訪問方式public static HungryChinese2 getInstance(){return hungryChinese2;}
}
class HungryChinese2Test{public static void main(String[] args) {HungryChinese2 instance = HungryChinese2.getInstance();HungryChinese2 instance1 = HungryChinese2.getInstance();System.out.println(instance.equals(instance1));}
}

????????這種方式與餓漢式類似，在類加載時通過靜態代碼塊創建實例，因此線程安全，但不能延遲加載。

枚舉式

????????枚舉式單例是一種簡潔且強大的實現方式。代碼如下：

public enum LazyMan5 {INSTANCE;
}
class LazyMan5Test{public static void main(String[] args) {LazyMan5 instance = LazyMan5.INSTANCE;LazyMan5 instance1 = LazyMan5.INSTANCE;System.out.println(instance == instance1);}
}

????????使用枚舉實現單例，不僅線程安全，調用效率高，而且天然地防止了反射和反序列化漏洞。在反序列化時，枚舉類型會保證返回的是已有的枚舉常量，而不會創建新的對象。不過，它同樣不能延遲加載。

應用場景

資源管理：如數據庫連接池、線程池等資源，使用單例模式可以確保整個系統中只有一個資源實例，避免資源的重復創建和浪費，提高資源的利用率和管理效率。
全局配置：系統的全局配置信息，如系統參數、環境變量等，使用單例模式可以方便地在整個系統中訪問和修改這些配置，保證配置的一致性。
日志記錄：日志記錄器通常使用單例模式，以便在整個應用程序中記錄日志信息。所有的日志記錄操作都通過同一個日志記錄器實例進行，方便管理和維護日志文件。
緩存管理：緩存系統可以使用單例模式來管理緩存實例，確保不同模塊對緩存的訪問和操作是一致的，提高緩存的命中率和性能。

單例模式可能面臨的問題及解決方案

Serializable問題

如果單例類實現了?java.io.Serializable?接口，在反序列化時可能會出現問題。因為反序列化過程會創建一個新的對象，這可能導致多次反序列化同一對象時得到多個單例類的實例，破壞了單例模式的唯一性。解決方法是在單例類中添加?readResolve?方法：

private Object readResolve() throws ObjectStreamException {return instance;
}

????????這樣，在反序列化時，如果定義了?readResolve?方法，則直接返回此方法指定的對象，而不會創建新的對象，從而保證了單例的唯一性。

在Android 中使用單例模式可能會內存泄漏

????????在 Android 開發中，當單例類依賴于?Context?時，如果傳入的是?Activity?的?Context，可能會導致內存泄漏。例如：

public class CommUtils {private volatile static CommUtils mCommUtils;private Context mContext;public CommUtils(Context context) {mContext=context;}public static  CommUtils getInstance(Context context) {if (mCommUtils == null) {synchronized (CommUtils.class) {if (mCommUtils == null) {mCommUtils = new CommUtils(context);}}}return mCommUtils;}
}

????????只要這個單例沒有被釋放，那么持有該單例的?Activity?也不會被釋放，直到進程退出。為了解決這個問題，應盡量使用?Application?的?Context，因為?Application?的生命周期伴隨著整個進程的周期，不會因為某個?Activity?的銷毀而導致單例持有無效的?Context，從而避免內存泄漏。