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

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

【設計模式】Java設計模式 - 單例模式
- 簡介
- 1、餓漢式
  - ①、餓漢靜態變數
  - ②、餓漢靜態代碼塊
- 2、懶漢式
  - ①、執行緒不安全
  - ②、執行緒安全
- 3、雙檢鎖/雙重校驗鎖（DCL，即 double-checked locking）
- 4、靜態內部類
- 5、列舉

簡介

單例模式，是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虛擬機提供的輕量級的同步機制，當某執行緒更新變數后，其他執行緒也能感知到，

關于volatile詳情可以看稀土掘金 https://juejin.cn/post/6861885337568804871
關于使用了synchronized為什么還要volatile？以及指令重排等的疑惑請看 CSDNhttps://blog.csdn.net/zengfanwei1990/article/details/110245035

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一步一步除錯，還有就是多看看別人的例子，能夠有助于理解！謝謝各位觀看指點！?? ?? ??

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/504505.html

標籤：設計模式

上一篇：設計模式之（9）——配接器模式

下一篇：【設計模式】Java設計模式 - 觀察者模式