【設計模式】Java設計模式 – 單例模式

【設計模式】Java設計模式 – 單例模式

😄 不斷學習才是王道
🔥 繼續踏上學習之路，學之分享筆記
👊 總有一天我也能像各位大佬一樣
🌝分享學習心得，歡迎指正，大家一起學習成長！
原創作品，更多關注我CSDN: 一個有夢有戲的人
準備將部落格園、CSDN一起記錄分享自己的學習心得！！！

目錄

簡介

單例模式，是java設計模式中最簡單的設計模式，是屬於創建類型模式。單例模式就是只能有一個實例，即一個類有且僅有一個實例，並且自行實例化向整個系統提供。

單例模式是設計模式中最簡單的形式之一。這一模式的目的是使得類的一個對象成為系統中的唯一實例。要實現這一點，可以從客戶端對其進行實例化開始。因此需要用一種只允許生成對象類的唯一實例的機制，「阻止」所有想要生成對象的訪問。使用工廠方法來限制實例化過程。這個方法應該是靜態方法（類方法），因為讓類的實例去生成另一個唯一實例毫無意義。 — （美）鍾冠賢．Objective-C編程之道 iOS設計模式解析．北京市：人民郵電出版社，2011

UML圖：
單例模式

以下使用多執行緒測試的程式碼（如以下例子）：

class Threads extends Thread {
    @Override
    public void run() {
        StaticVariableStarve instance = StaticVariableStarve.getInstance();
        System.out.println("StaticVariableStarve hashCode: " + instance.hashCode());
    }
}

在main方法中調用start。

for (int i = 0; i < 5; i++) {
    new Threads().start();
}

1、餓漢式

①、餓漢靜態變數

餓漢靜態變數通過創建靜態變數去實例化對象，在通過靜態方法返回實例，其中需要實現私有化構造方法，使得外部不能通過new直接實例化對象。
程式碼如下：

package com.lyd.demo.singleton;

/**
 * @Author: lyd
 * @Description: 單例模式 - 餓漢靜態變數
 * @Date: 2022-08-24
 */
public class StaticVariableStarve {
    // 私有化構造方法
    private StaticVariableStarve() {
    }
    // 創建靜態變數實例化
    private final static StaticVariableStarve singleton = new StaticVariableStarve();
    // 返回對象
    public static StaticVariableStarve getInstance() {
        return singleton;
    }
}

餓漢靜態變數的測試

單例模式創建只能有一個實例，不管是用幾個變數，最後他們都是同一個實例，如下測試，通過「==」判斷對象實例是否一致，列印其hashcode可以發現是一樣的。

// 餓漢靜態變數
StaticVariableStarve singleton1 = StaticVariableStarve.getInstance();
StaticVariableStarve singleton2 = StaticVariableStarve.getInstance();
System.out.println("兩者是否相同？" + (singleton1 == singleton2));
System.out.println("singleton1的hashcode：" + (singleton1.hashCode()));
System.out.println("singleton2的hashcode：" + (singleton2.hashCode()));

運行結果：
在這裡插入圖片描述
多執行緒：
在這裡插入圖片描述

這樣寫在類裝載的時候就已經實例化了，避免了執行緒安全問題。但是，一開始就已經實例化了，沒有使用lazy loading，就會導致有時候這個實例不需要使用，但是他仍然實例化了，這樣就造成了記憶體浪費。

②、餓漢靜態程式碼塊

靜態程式碼塊中實例化對象，通過類主動去實例化對象，當調用到這個類的時候，靜態程式碼塊的程式碼就會運行，從而實例化對象。
程式碼如下：

package com.lyd.demo.singleton;

/**
 * @Author: lyd
 * @Description: 餓漢靜態程式碼塊
 * @Date: 2022-08-24
 */
public class StaticBlockStarve {
    // 私有化構造方法
    private StaticBlockStarve() {
    }
    // 構建靜態變數
    private static StaticBlockStarve singleton;
    static {
        singleton = new StaticBlockStarve();
    }
    // 返回對象
    public static StaticBlockStarve getInstance() {
        return singleton;
    }
}

餓漢靜態程式碼塊測試

// 餓漢靜態程式碼塊
StaticBlockStarve singleton3 = StaticBlockStarve.getInstance();
StaticBlockStarve singleton4 = StaticBlockStarve.getInstance();
System.out.println("兩者是否相同？" + (singleton3 == singleton4));
System.out.println("singleton1的hashcode：" + (singleton3.hashCode()));
System.out.println("singleton2的hashcode：" + (singleton4.hashCode()));

運行結果:
在這裡插入圖片描述
多執行緒：
在這裡插入圖片描述

2、懶漢式

①、執行緒不安全

通過 Lazy 初始化，但是執行緒不安全，這種方式是最基本的實現方式，這種實現最大的問題就是不支援多執行緒。因為沒有加鎖 synchronized，所以嚴格意義上它並不算單例模式。
這種方式 lazy loading 很明顯，不要求執行緒安全，在多執行緒不能正常工作。
程式碼如下：

通過getInstance()獲取實例，在方法內進行判斷是否為空，不為空直接返回對象實例。

package com.lyd.demo.singleton;

/**
 * @Author: lyd
 * @Description: 懶漢式-執行緒不安全
 * @Date: 2022-08-24
 */
public class NotSafeThreadLazy {
    // 私有變兩個
    private static NotSafeThreadLazy singleton;
    // 私有構造
    private NotSafeThreadLazy() {
    }
    // 通過方法實例化
    public static NotSafeThreadLazy getInstance() {
        if (singleton == null) {
            singleton = new NotSafeThreadLazy();
        }
        return singleton;
    }
}

測試

// 懶漢執行緒不安全
NotSafeThreadLazy singleton1 = NotSafeThreadLazy.getInstance();
NotSafeThreadLazy singleton2 = NotSafeThreadLazy.getInstance();
System.out.println("兩者是否相同？" + (singleton1 == singleton2));
System.out.println("singleton1的hashcode：" + (singleton1.hashCode()));
System.out.println("singleton2的hashcode：" + (singleton2.hashCode()));

運行結果
在這裡插入圖片描述
多執行緒：可見生成了多個實例
在這裡插入圖片描述

用到了lazy loading，但只能在單執行緒下使用。但是在多執行緒中，可能會導致一個執行緒已經到達了if判空，但是還沒有進行實例化，第二個執行緒就已經進入判空，並且也進入實例化。這樣就會破壞了單例模式，兩個實例化就不是同一個，因此這種方式是執行緒不安全，不推薦使用。

②、執行緒安全

這種方式具備很好的 lazy loading，能夠在多執行緒中很好的工作，但是，效率很低，99% 情況下不需要同步。
程式碼如下：

通過lazy loading實例化對象，只在第一次運行實例化，在getInstance方法中使用synchronized保證執行緒安全。

package com.lyd.demo.singleton;

/**
 * @Author: lyd
 * @Description: 懶漢式-執行緒安全
 * @Date: 2022-08-24
 */
public class SafeThreadLazy {
    // 私有變兩個
    private static SafeThreadLazy singleton;
    // 私有構造
    private SafeThreadLazy() {
    }
    // 通過方法實例化
    public static synchronized SafeThreadLazy getInstance() {
        if (singleton == null) {
            singleton = new SafeThreadLazy();
        }
        return singleton;
    }
}

多執行緒 ：
在這裡插入圖片描述

3、雙檢鎖/雙重校驗鎖（DCL，即 double-checked locking）

採用雙鎖機制，安全且在多執行緒情況下能保持高性能。

在變數加上關鍵字volatile，在實例化的時候用synchronized執行緒鎖，可以使執行緒安全。
volatile：是Java虛擬機提供的輕量級的同步機制，當某執行緒更新變數後，其他執行緒也能感知到。

package com.lyd.demo.singleton;

/**
 * @Author: lyd
 * @Description: 雙檢鎖/雙重校驗鎖
 * @Date: 2022-08-24
 */
public class DoubleCheckedLocking {
    // 私有變兩個
    private static volatile DoubleCheckedLocking singleton;
    // 私有構造
    private DoubleCheckedLocking() {
    }
    // 通過方法實例化
    public static DoubleCheckedLocking getInstance() {
        if (singleton == null) { // [1]
            synchronized (DoubleCheckedLocking.class) { // [2]
                if (singleton == null) {
                    singleton = new DoubleCheckedLocking();
                }
            }
        }
        return singleton;
    }
}

在getInstance()方法中，哪怕是多執行緒，都能保證執行緒安全以及單例模式。假如有多個執行緒，一個執行緒先到達了[1]判空成功後進入實例化，此時synchronized執行緒鎖就會上鎖，在還沒實例化後，然而其他執行緒也過來了，他們也通過了[1]判空，但是在[2]處會被攔住，直到前一個實例化結束後才解鎖，等到解鎖後，也就已經實例化完成，singleton就已經不再是null。

多執行緒：
在這裡插入圖片描述

4、靜態內部類

這種方式能達到雙檢鎖方式一樣的功效，但實現更簡單。對靜態域使用延遲初始化，應使用這種方式而不是雙檢鎖方式。這種方式只適用於靜態域的情況，雙檢鎖方式可在實例域需要延遲初始化時使用。
程式碼如下：

通過SingletonHolder這個靜態內部類實例化，採用類裝載的方式進行實例化，但是一開始是不會實例化的，只有顯式調用了getInstance()，使得SingletonHolder類被主動調用，從而實例化對象。

package com.lyd.demo.singleton;

/**
 * @Author: lyd
 * @Description: 靜態內部類
 * @Date: 2022-08-24
 */
public class StaticInnerClass {
    private StaticInnerClass() {}
    // 靜態內部類
    public static class SingletonHolder {
        private static final StaticInnerClass SINGLETON = new StaticInnerClass();
    }
    // 調用方法
    public static StaticInnerClass getInstance() {
        return SingletonHolder.SINGLETON;
    }
}

採用了類裝載的方式使實例化只有一個執行緒。在一開始StaticInnerClass被裝載的時候，對象不一定被實例化。需要調用了getInstace()的方法，才會使得SingletonHolder被主動使用，裝載SingletonHolder類，也就接著進行實例化對象。

多執行緒：
在這裡插入圖片描述

5、枚舉

這種實現方式還沒有被廣泛採用，但這是實現單例模式的最佳方法。它更簡潔，自動支援序列化機制，絕對防止多次實例化。
這種方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不僅能避免多執行緒同步問題，而且還自動支援序列化機制，防止反序列化重新創建新的對象，絕對防止多次實例化。
程式碼如下：

package com.lyd.demo.singleton;

/**
 * @Author: lyd
 * @Description:
 * @Date: 2022-08-24
 */
public enum Enumeration {
    INSTANCE;
    public void instanceMethod() {
        System.out.println("實例的方法");
    }
}

測試

// 枚舉
Enumeration instance = Enumeration.INSTANCE;
Enumeration instance2 = Enumeration.INSTANCE;
System.out.println("兩者是否相同？" + (instance == instance2));
System.out.println("instance的hashcode：" + (instance.hashCode()));
System.out.println("instance2的hashcode：" + (instance2.hashCode()));
instance.instanceMethod();

結果
在這裡插入圖片描述
多執行緒測試：
在這裡插入圖片描述
可發現多執行緒下枚舉也是能夠實現單例模式。

👍創作不易，如有錯誤請指正，感謝觀看！記得一鍵三連哦！👍

💓德德小建議：

理解設計模式不是一件簡單的事情，需要不斷的學習和動手去練習，才能理解。只有掌握好設計模式，才能夠真正的理解SpringAOP和Mybatis的底層原理。各位讀者可以和我一樣，動手敲一敲程式碼，甚至用不同的例子來做，通過debug一步一步調試，還有就是多看看別人的例子。能夠有助於理解！謝謝各位觀看指點！❤️ ❤️ ❤️

Tags:

VirMach 便宜 VPS

QNews

QNews