JAVA的單例模式實例分析

這篇文章主要介紹“JAVA的單例模式實例分析”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“JAVA的單例模式實例分析”文章能幫助大家解決問題。

一、單例模式是什么？

單例（Singleton）模式的定義：指一個類只有一個實例,且該類能自行創建這個實例的一種模式。

作用:單例模式是保證系統實例唯一性的重要手段。用于一個全局類對象在多個地方被使用的場景下,保障了整個系統只有一個對象被使用,很好的節約了資源

實現方法:將類的實例化方法私有化來防止程序通過其他方式創建該類的實例,提供一個全局唯一獲取該類實例的方法幫助用戶獲取類的實例。

實現單例模式很簡單,每次獲取前先判斷系統是否已經存在單例對象,沒有就創建,有就返回這個對象。單例模式常見的寫法有懶漢式單例和餓漢式單例。

二、懶漢式單例

定義:類加載時沒有生成單例,第一次調用 getlnstance 方法時創建這個單例。

public class LazySingleton {

    //定義一個私有的靜態對象instance,靜態方法和屬性屬于類,能保障單例對象的唯一性
    private static LazySingleton instance;

    //私有化構造方法,只能在本類中被訪問,其他類中不能通過構造方法直接創建對象
    private LazySingleton() {
    }

    //提供一個全局唯一獲取實例的方法
    public static synchronized LazySingleton getInstance(){
        if(instance==null){
            instance=new LazySingleton();
        }
        return instance;
    }
}

懶漢模式在獲取對象實例時做了加鎖操作,因此是線程安全的

測試代碼與結果

public class TestLazySingleton {
    public static void main(String[] args) {
        LazySingleton lazySingleton1=LazySingleton.getInstance();
        LazySingleton lazySingleton2=LazySingleton.getInstance();
        LazySingleton lazySingleton3=LazySingleton.getInstance();
        System.out.println(lazySingleton1);
        System.out.println(lazySingleton2);
        System.out.println(lazySingleton3);
    }
}

從上圖中可以看出雖然獲取了三次實例,但每次獲取的都是同一個實例,即一個類只有一個實例。

三、餓漢式單例

定義:該模式的特點是類一旦加載就創建一個單例，在調用 getInstance 方法之前單例已經存在。

public class HungrySingleton {
    //類加載完成后該類的實例便已經存在
    private static HungrySingleton instance=new HungrySingleton();
    //私有化構造方法
    private HungrySingleton(){
    }
    //類加載后實例就存在,不會出現線程安全問題,不需要加鎖
    public static HungrySingleton getInstance(){
        return  instance;
    }
}

測試代碼和結果

public class TestHungrySingleton {
    public static void main(String[] args) {
       HungrySingleton hungrySingleton1=HungrySingleton.getInstance();
       HungrySingleton hungrySingleton2=HungrySingleton.getInstance();
       HungrySingleton hungrySingleton3=HungrySingleton.getInstance();
        System.out.println(hungrySingleton1);
        System.out.println(hungrySingleton2);
        System.out.println(hungrySingleton3);
    }
}

從上圖看出餓漢式單例在整個運行過程中也只存在一個實例。

懶漢式單例和餓漢式單例的區別
1.懶漢模式在類中定義了單例但是并未實例化,實例化是在方法中實現的,而餓漢模式定義的時候就進行了實例化
2.懶漢模式需要在獲取實例的方法上加鎖保證線程安全,餓漢模式不需要加鎖。

四、雙重校驗鎖

懶漢模式用到了synchronized，會導致很大的性能開銷，并且加鎖其實只需要在第一次初始化的時候用到，之后的調用都沒必要再進行加鎖。

雙重校驗鎖在懶漢模式的基礎上做了進一步的優化,給靜態對象加上volatile來保證有序性,第一次獲取對象時通過synchronize(Singleton.class)保障操作的唯一性。

public class LockSingleton {
    private  volatile static LockSingleton lockSingleton;
    private LockSingleton(){}
    public static LockSingleton getInstance(){
        if(lockSingleton==null){
            synchronized (LockSingleton.class){
                if (lockSingleton==null){
                    lockSingleton=new LockSingleton();
                }
            }
        }
        return lockSingleton;
    }
}

測試代碼與結果

public class LockTest {
    public static void main(String[] args) {
        LockSingleton lockSingleton1=LockSingleton.getInstance();
        LockSingleton lockSingleton2=LockSingleton.getInstance();
        LockSingleton lockSingleton3=LockSingleton.getInstance();
        System.out.println(lockSingleton1);
        System.out.println(lockSingleton2);
        System.out.println(lockSingleton3);
    }
}

執行雙重檢查是因為，如果多個線程同時了通過了第一次檢查，并且其中一個線程首先通過了第二次檢查并實例化了對象，那么剩余通過了第一次檢查的線程就不會再去實例化對象。

除了第一次創建實例的時候會出現加鎖的情況，后續的所有調用都會避免加鎖而直接返回，解決了性能消耗的問題。

關于“JAVA的單例模式實例分析”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。