設計模式學習筆記——單例模式

穩重的窩瓜發表於2020-12-06

設計模式筆記單例

單例模式

單例設計模式，就是採取一定的方法保證在整個軟體系統中，對某個類只能存在一個物件例項，並且該類只提供一個取得其物件例項的方法（靜態方法）。

單例模式的八種實現方式

餓漢式（靜態常量）
餓漢式（靜態程式碼塊）
懶漢式（執行緒不安全）
懶漢式（執行緒安全，同步方法）
懶漢式（執行緒安全，同步程式碼塊）
雙重檢查——推薦使用
靜態內部類——推薦使用
列舉——推薦使用

餓漢式（靜態常量）

實現步驟：

私有化構造器
建立靜態例項
對外暴露一個獲取例項的靜態方法

程式碼實現：

package com.test.singleton;

/**
 * @Author: junwe
 * @Date: 2020/12/6 16:25
 */
public class SingletonTest1 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode() == instance2.hashCode());
    }

}

/**
 * 餓漢式-靜態常量
 */
class Singleton {

    /**
     * 私有化構造器，外部類不能new物件
     */
    private Singleton() {}

    // 類被載入的時候建立物件例項
    private final static Singleton INSTANCE = new Singleton();

    /**
     * 提供一個公有的靜態方法返回物件例項
     * @return
     */
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

執行結果：

優點：寫法簡單，在類載入的時候就完成了例項化。避免了執行緒同步的問題。

缺點：在類載入的時候就完成例項化，沒有達到lazy loading的效果。如果這個類一直未被使用，則會造成資源浪費。

結論：這種單例模式可用，但是可能造成記憶體浪費。

餓漢式（靜態程式碼塊）

程式碼實現：

package com.test.singleton.test2;

/**
 * @Author: junwe
 * @Date: 2020/12/6 16:55
 */
public class SingletonTest2 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
        System.out.println(instance1.hashCode() == instance2.hashCode());
    }

}

/**
 * 餓漢式-靜態程式碼塊
 */
class Singleton {

    /**
     * 私有化構造器，外部類不能new物件
     */
    private Singleton() {}

    private static Singleton INSTANCE;

    /**
     * 靜態程式碼塊執行的時候建立物件例項
     */
    static {
        INSTANCE = new Singleton();
    }

    /**
     * 提供一個公有的靜態方法返回物件例項
     * @return
     */
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

執行結果：

優缺點同餓漢式（靜態常量）

懶漢式（執行緒不安全）

程式碼實現：

package com.test.singleton.test3;

/**
 * @Author: junwe
 * @Date: 2020/12/6 17:21
 */
public class SingletonTest3 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new GetInstanceThread()).start();
        }
    }
}

/**
 * 懶漢式-執行緒不安全
 */
class Singleton {

    /**
     * 私有化構造器，外部類不能new物件
     */
    private Singleton() {
    }

    private static Singleton INSTANCE;

    /**
     * 提供一個公有的靜態方法返回物件例項
     * 當使用到該方法時才建立例項
     *
     * @return
     */
    public static Singleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Singleton();
        }
        // 列印出例項的hashcode值
        System.out.println(INSTANCE.hashCode());
        return INSTANCE;
    }
}

class GetInstanceThread implements Runnable{

    @Override
    public void run() {
        Singleton.getInstance();
    }
}

執行結果：

優缺點：

起到了lazy loading的效果，但是隻能在單執行緒下使用。
如果在多執行緒下，一個執行緒進入了if(INSTANCE == null) ，還未來得及往下執行，另外一個執行緒也通過了這個判斷語句，這時就會產生多個例項。所以在多執行緒環境下不可以使用這種方式。

懶漢式（執行緒安全，同步方法）

程式碼實現：

package com.test.singleton.test4;

/**
 * @Author: junwe
 * @Date: 2020/12/6 21:15
 */
public class SingletonTest4 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new GetInstanceThread()).start();
        }
    }
}

/**
 * 懶漢式-同步方法
 */
class Singleton {

    /**
     * 私有化構造器，外部類不能new物件
     */
    private Singleton() {
    }

    private static Singleton INSTANCE;

    /**
     * 提供一個公有的靜態方法返回物件例項
     * 當使用到該方法時才建立例項
     * 加入同步程式碼，解決執行緒不安全問題
     * @return
     */
    public static synchronized Singleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new Singleton();
        }
        System.out.println(INSTANCE.hashCode());
        return INSTANCE;
    }
}

class GetInstanceThread implements Runnable{

    @Override
    public void run() {
        Singleton.getInstance();
    }
}

執行結果：

優缺點：

解決了執行緒不安全的問題。
效率低，每個執行緒在獲得類的例項的時候，執行getInstance()方法都要進行同步。其實這個方法只執行一次例項化程式碼就好了，後面的想獲取該類例項可以直接return。方法進行同步效率太低。

懶漢式（執行緒安全，同步程式碼塊）

程式碼實現：

package com.test.singleton.test4;

/**
 * @Author: junwe
 * @Date: 2020/12/6 21:15
 */
public class SingletonTest4 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new GetInstanceThread()).start();
        }
    }
}

/**
 * 懶漢式-同步程式碼塊
 */
class Singleton {

    /**
     * 私有化構造器，外部類不能new物件
     */
    private Singleton() {
    }

    private static Singleton INSTANCE;

    /**
     * 提供一個公有的靜態方法返回物件例項
     * 當使用到該方法時才建立例項
     * 加入同步程式碼塊，不能解決執行緒安全問題
     *
     * @return
     */
    public static Singleton getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                INSTANCE = new Singleton();
            }
        }
        System.out.println(INSTANCE.hashCode());
        return INSTANCE;
    }
}

class GetInstanceThread implements Runnable {

    @Override
    public void run() {
        Singleton.getInstance();
    }
}

執行結果：

優缺點：

這種方法的本意是對懶漢式（執行緒安全，同步方法）的改進，改為同步產生例項化的程式碼塊。
但是這種同步並不能起到執行緒同步的作用。如果一個執行緒進入了if (INSTANCE == null)判斷，還沒來得級往下執行，另一個執行緒也通過了這個判斷，這時就會產生多個例項。

雙重檢查

程式碼實現：

package com.test.singleton.test5;

/**
 * @Author: junwe
 * @Date: 2020/12/6 21:45
 */
public class SingletonTest4 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new GetInstanceThread()).start();
        }
    }
}

/**
 * 懶漢式-雙重鎖
 */
class Singleton {

    /**
     * 私有化構造器，外部類不能new物件
     */
    private Singleton() {
    }

    /**
     * volatile：禁止指令重排，保證記憶體可見性
     */
    private static volatile Singleton INSTANCE;

    /**
     * 提供一個公有的靜態方法返回物件例項
     * 當使用到該方法時才建立例項
     * 雙重鎖，解決執行緒安全問題，同時解決懶載入問題
     * 同時保證高效
     * @return
     */
    public static Singleton getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }
        }
        System.out.println(INSTANCE.hashCode());
        return INSTANCE;
    }
}

class GetInstanceThread implements Runnable {

    @Override
    public void run() {
        Singleton.getInstance();
    }
}

執行結果：

優缺點：

例項化程式碼只執行一次，後面再次訪問時，判斷if (INSTANCE == null)，直接返回例項化對現象，避免了反覆進行方法同步。
執行緒安全：延遲載入、效率高。
推薦使用這種單例模式

靜態內部類

程式碼實現：

package com.test.singleton.test6;


/**
 * @Author: junwe
 * @Date: 2020/12/6 22:02
 */
public class SingletonTest5 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new GetInstanceThread()).start();
        }
    }
}

/**
 * 靜態內部類
 */
class Singleton {
    /**
     * 私有化構造器，外部類不能new物件
     */
    private Singleton() {
    }

    /**
     * 靜態內部類
     * 當外部類Singleton被載入的時候，靜態內部類SingletonInstance不會馬上被載入，保證lazy loading
     */
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    /**
     * 當呼叫該方法時，SingletonInstance類會被載入，靜態常量INSTANCE僅會被載入一次
     *
     * @return
     */
    public static Singleton getInstance() {
        System.out.println(SingletonInstance.INSTANCE.hashCode());
        return SingletonInstance.INSTANCE;
    }
}

class GetInstanceThread implements Runnable {

    @Override
    public void run() {
        Singleton.getInstance();
    }
}

執行結果：

優缺點：

採用了類載入機制來保證初始化例項時只有一個執行緒。
靜態內部類方式在Singleton類被載入時並不會立即被例項化，而是在需要例項化時，呼叫getInstance()方法時才會載入靜態內部類SingletonInstance，從而完成Singleton的例項化。
類的靜態屬性只會在類第一次載入的時候初始化，JVM幫我們保證了執行緒安全。
優點：執行緒安全的，利用靜態內部類的特點實現延遲載入，效率高。

列舉

程式碼實現：

package com.test.singleton.test7;

/**
 * @Author: junwe
 * @Date: 2020/12/6 22:30
 */
public class SingletonTest6 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new GetInstanceThread()).start();
        }
    }
}

enum Singleton {
    INSTANCE;
}

class GetInstanceThread implements Runnable {

    @Override
    public void run() {
        System.out.println(Singleton.INSTANCE.hashCode());
    }
}

執行結果：

優缺點：

藉助JDK1.5新增的列舉類來實現單例模式，不僅能避免多執行緒同步問題，而且還能防止反序列化重新建立物件。
關於列舉實現單例的詳細可以看看這篇部落格https://www.cnblogs.com/chiclee/p/9097772.html

Java設計模式學習筆記(五) 單例模式
2019-07-18
Java設計模式筆記單例
設計模式學習之單例模式
2018-12-29
設計模式單例
設計模式快速學習（三）單例模式
2018-08-06
設計模式單例
設計模式之“物件效能模式”： Singleton 單例模式（筆記）
2019-02-22
設計模式物件單例筆記
設計模式學習（一）單例模式補充——單例模式析構
2024-03-19
設計模式單例
學習筆記-設計模式：MVC模式
2018-10-17
筆記設計模式MVC
小學生學習設計模式之單例模式
2020-04-06
設計模式單例
從JavaScript學習設計模式-02單例模式
2019-02-23
JavaScript設計模式單例
設計模式學習筆記
2022-01-07
設計模式筆記
學習筆記-設計模式
2021-01-01
筆記設計模式
設計模式學習筆記（四）單例模式的實現方式和使用場景
2022-03-26
設計模式筆記單例
Java設計模式學習筆記(二) 簡單工廠模式
2019-07-15
Java設計模式筆記
重學設計模式-單例模式
2021-05-24
設計模式單例
C++學習隨筆——簡單的單例設計模式例項
2024-08-26
C++單例設計模式
設計模式學習-使用go實現單例模式
2021-11-04
設計模式Go單例
Java設計模式學習筆記(一) 設計模式概述
2019-07-11
Java設計模式筆記
php設計模式學習筆記
2019-04-03
PHP設計模式筆記
JavaScript設計模式學習筆記
2020-05-27
JavaScript設計模式筆記
設計模式學習筆記之工廠模式
2019-01-19
設計模式筆記
設計模式學習（一）單例模式補充——指令重排
2024-03-19
設計模式單例
設計模式（單例模式）
2018-08-20
設計模式單例
[設計模式] 單例模式
2020-01-16
設計模式單例
設計模式-單例模式
2020-08-25
設計模式單例
設計模式 —— 單例模式
2019-02-18
設計模式單例
設計模式單例模式
2024-07-31
設計模式單例
設計模式——單例模式
2021-10-19
設計模式單例
設計模式之單例模式（《JavaScript設計模式與開發實踐》讀書筆記）
2018-06-07
設計模式單例JavaScript筆記
設計模式學習筆記之裝飾者模式
2018-10-16
設計模式筆記
設計模式-單例模式、多例模式
2020-12-14
設計模式單例
Event Bus 設計模式學習筆記
2021-09-26
設計模式筆記
設計模式之單例設計模式
2020-04-18
設計模式單例
設計模式(一)_單例模式
2018-06-05
設計模式單例
常用設計模式-單例模式
2024-04-26
設計模式單例
設計模式之單例模式
2023-09-23
設計模式單例
Java設計模式【單例模式】
2023-05-12
Java設計模式單例
Java設計模式 | 單例模式
2020-10-24
Java設計模式單例
001設計模式：單例模式
2020-10-08
設計模式單例
# Python設計模式單例模式
2020-07-05
Python設計模式單例

設計模式學習筆記——單例模式

單例模式

單例模式的八種實現方式

餓漢式（靜態常量）

餓漢式（靜態程式碼塊）

懶漢式（執行緒不安全）

懶漢式（執行緒安全，同步方法）

懶漢式（執行緒安全，同步程式碼塊）

雙重檢查

靜態內部類

列舉

相關文章