單例模式簡介：

單例模式優點:

應用場景：

單例設計模式的八種方式:

1、餓漢式（靜態常量）

2、餓漢式（靜態代碼塊）

3、懶漢式（執行緒不安全）

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

5、懶漢式（執行緒安全，同步代碼塊）

6、雙重檢查（推薦使用）

7、靜態內部類(推薦使用)

8、列舉（推薦使用）

單例模式在JDK應用的原始碼分析

單例模式注意事項和細節說明

單例模式簡介：

單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一，這種型別的設計模式屬于創建型模式，它提供了一種創建物件的最佳方式，

這種模式涉及到一個單一的類，該類負責創建自己的物件，同時確保只有單個物件被創建，這個類提供了一種訪問其唯一的物件的方式，可以直接訪問，不需要實體化該類的物件，

比如Hibernate的SessionFactory，它充當資料存盤源的代理，并負責創建Session物件，SessionFactory并不是輕量級的，一般情況下，一個專案通常只需要一個SessionFactory就夠，這是就會使用到單例模式，

單例模式優點:

由于其在記憶體中只有一個物件實體，則節省記憶體空間
能避免頻繁地創建和銷毀物件，提高性能
避免對共享資源的多重占用，簡化訪問操作，如在進行寫檔案時，由于只有一個實體物件，能避免對同一資源的同時寫操作
為整個系統提供一個全域訪問點，優化和共享資源訪問，

應用場景：

單例模式其核心在于在整個系統中只創建唯一一個實體，其應用場景主要如下：

1.創建物件時耗時過多或者耗資源過多，但又經常用到的物件，
2.需要頻繁實體化然后銷毀的物件，如多執行緒的執行緒池、網路連接池等，
3.當物件需要被共享的場合，由于單例模式只允許創建一個物件，共享該物件可以節省記憶體，并加快物件訪問速度，如 Web 中的配置物件、資料庫的連接池等，
4.需要頻繁創建的一些類，使用單例可以降低系統的記憶體壓力，減少 GC，
5.網站的計數器（否則難以同步）
6.Windows的任務管理器和回收站，

單例設計模式的八種方式:

1、餓漢式（靜態常量）

應用實體：

1.構造器私有化（防止new）

2.類的內部創建物件

3.向外暴露一個靜態的公共方法：getInstance

4.代碼實作

public class SingletonTest01 {
    public static void main(String[] args) {
        //測驗
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1=instance1);    //true
        System.out.println("instance1.hsashCode="+instance1.hashCode());
        System.out.println("instance2.hsashCode="+instance2.hashCode());
    }
}
//餓漢式顧名思義是饑餓的，因此應該開始就創建物件
class Singleton{
    // 1.構造器私有化,外部不能new
    private Singleton(){
    }
    // 2.本類內部創建物件實體
    private final static Singleton instance=new Singleton();
    // 3.提供一個公有的靜態方法，回傳實體物件
    public static Singleton getInstance(){
        return instance;
    }
}

運行結果：

優缺點說明:
1、優點:這種寫法比較簡單，就是在類裝載的時候就完成實體化，避免了執行緒同步問題，
2、缺點:在類裝載的時候就完成實體化，沒有達到Lazy Loading 的效果，如果從始至終從未使用過這個實體，則會造成記憶體的浪費
3、這種方式基于classloder機制避免了多執行緒的同步問題，不過，instance在類裝載時就實體化，在單例模式中大多數都是呼叫getInstance方法，但是導致類裝載的原因有很多種，因此不能確定有其他的方式(或者其他的靜態方法）導致類裝載，這時候初始化instance就沒有達到lazy loading 的效果
結論:這種單例模式可用，但是可能造成記憶體浪費

2、餓漢式（靜態代碼塊）

class Singleton01{
    // 1.構造器私有化,外部不能new
    private Singleton01(){
    }
    // 2.本類內部創建物件實體
    private  static Singleton01 instance;
    static {  //在靜態代碼塊中，創建單例物件
        instance=new Singleton01();
    }
    // 3.提供一個公有的靜態方法，回傳實體物件
    public static Singleton01 getInstance(){
        return instance;
    }
}

優缺點說明：和上面一樣這種方式和上面的方式其實類似，只不過將類實體化的程序放在了靜態代碼塊中，也就是在類裝載的時候，就執行靜態代碼塊中的代碼，初始化類的實體，

3、懶漢式（執行緒不安全）

public class SingletonTest03 {
    public static void main(String[] args) {
        //測驗
        System.out.println("懶漢式，執行緒不安全~");
        Singleton03 instance1 = Singleton03.getInstance();
        Singleton03 instance2 = Singleton03.getInstance();
        System.out.println(instance1==instance2);    //true
        System.out.println("instance1.hsashCode="+instance1.hashCode());
        System.out.println("instance2.hsashCode="+instance2.hashCode());
    }
}
//懶漢式顧名思義就是懶，不會跟餓漢式一樣上來就創建物件，而是在需要的時候才會創建，而且是僅創建一次
class Singleton03{
    // 1.構造器私有化,外部不能new
    private Singleton03(){
    }
    // 2.本類內部創建物件實體
    private  static Singleton03 instance;

    // 3.提供一個公有的靜態方法，當使用到該方法時，才會去創建instance
    //即懶漢式
    public static Singleton03 getInstance(){
        if(instance==null){
            instance=new Singleton03();
        }
        return instance;
    }
}

運行結果：

優缺點說明:
1、起到了Lazy Loading的效果，但是只能在單執行緒下使用，
2、如果在多執行緒下，一個執行緒進入了if (singleton == mull)判斷陳述句塊，還未來得及往下執行，另一個執行緒也通過了這個判斷陳述句，這時便會產生多個實體，所以在多執行緒環境下不可使用這種方式
3、結論:在實際開發中，不要使用這種方式.

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

class Singleton04{
    // 1.構造器私有化,外部不能new
    private Singleton04(){
    }
    // 2.本類內部創建物件實體
    private  static Singleton04 instance;
    // 3.提供一個公有的靜態方法，加入同步處理的代碼，解決執行緒安全問題
    //即懶漢式
    public static synchronized  Singleton04 getInstance(){
        if(instance==null){
            instance=new Singleton04();
        }
        return instance;
    }
}

運行結果：

優缺點說明:
1、解決了執行緒安全問題
2、效率太低了，每個執行緒在想獲得類的實體時候，執行getInstance()方法都要進行同步，而其實這個方法只執行一次實體化代碼就夠了，后面的想獲得該類實體，直接return就行了，方法進行同步效率太低
3、結論:在實際開發中，不推薦使用這種方式

5、懶漢式（執行緒安全，同步代碼塊）

class Singleton05{
    // 1.構造器私有化,外部不能new
    private Singleton05(){
    }
    // 2.本類內部創建物件實體
    private  static Singleton05 instance;
    // 3.提供一個公有的靜態方法，加入同步代碼塊
    public static Singleton05 getInstance(){
        if(instance==null){
          synchronized (Singleton05.class){
              instance=new Singleton05();
          }
        }
        return instance;
    }
}

優缺點說明：

1、這種方式，本意是想對第四種實作方式的改進，因為前面同步方法效率太低，改為同步產生實體化的的代碼塊
2、但是這種同步并不能起到執行緒同步的作用，跟第3種實作方式遇到的情形一致，假如一個執行緒進入了if (singleton == nul)判斷陳述句塊，還未來得及往下執行，另一個執行緒也通過了這個判斷陳述句，這時便會產生多個實體
結論:在實際開發中，不能使用這種方式

6、雙重檢查（推薦使用）

//雙重檢查
class Singleton06{
    // 1.構造器私有化,外部不能new
    private Singleton06(){
    }
    // 2.本類內部創建物件實體
    private  static volatile Singleton06 instance;
    // 3.提供一個公有的靜態方法，加入雙重檢查代碼,解決執行緒安全問題，同時解決懶加載問題
    public static synchronized Singleton06 getInstance(){
        if(instance==null){
          synchronized (Singleton06.class){
              if(instance==null){
                  instance=new Singleton06();
              }
          }
        }
        return instance;
    }
}

運行結果：

優缺點說明：

1、Double-Check 概念是多執行緒開發中常使用到的，如代碼中所示，我們進行了兩次if (singleton==- null)檢查，這樣就可以保證執行緒安全了，
2、這樣，實體化代碼只用執行一次，后面再次訪問時，判斷if (singleton ==null)，直接return實體化物件，也避免的反復進行方法同步.
3、執行緒安全;延遲加載;效率較高
4、結論:在實際開發中，推薦使用這種單例設計模式

為什么一定使用volatile?

在java記憶體模型中，volatile 關鍵字作用是：

保證不同執行緒對變數操作的記憶體可見性
禁止指令重排序

7、靜態內部類(推薦使用)

//靜態內部類完成，推薦使用
class Singleton07{
    // 1.構造器私有化
    private Singleton07(){
    }
    // 2.本類內部創建物件實體
    private  static volatile Singleton07 instance;
    //寫一個內部靜態類，該類中有一個靜態的屬性
    private static class SingletonInstance{
        private static final Singleton07 INSTANCE=new Singleton07();
    }
    // 3.提供一個公有的靜態方法，直接回傳SingletonInstance.INSTANCE
    public static synchronized Singleton07 getInstance(){

        return SingletonInstance.INSTANCE;
    }
}

運行結果：

優缺點說明:
1、這種方式采用了類裝載的機制來保證初始化實體時只有一個執行緒，

2、靜態內部類方式在Singleton類被裝載時并不會立即實體化，而是在需要實體化時，呼叫getInstance方法，才會裝載SingletonInstance類，從而完成Singleton的實體化，
3、類的靜態屬性只會在第一次加載類的時候初始化，所以在這里，JVM幫助我們保證了執行緒的安全性，在類進行初始化時，別的執行緒是無法進入的，
4、優點:避免了執行緒不安全，利用靜態內部類特點實作延遲加載，效率高

8、列舉（推薦使用）

public class SingletonTest08 {
    public static void main(String[] args) {
        Singleton08 instance = Singleton08.INSTANCE;
        Singleton08 instance2 = Singleton08.INSTANCE;
        System.out.println(instance==instance2);

        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
        instance.sayOk();
    }
}
//使用列舉，可以實作單例，推薦
enum Singleton08{
    INSTANCE;//屬性
    public void sayOk(){
        System.out.println("ok~");
    }
}

運行結果：

優缺點：

1、這借助JDK1.5中添加的列舉來實作單例模式，不僅能避免多執行緒同步問題，而且還能防止反序列化重新創建新的物件，
2、這種方式是Effective Java作者Josh Bloch提倡的

3、方式結論:推薦使用

單例模式在JDK應用的原始碼分析

在我們JDK中，java.lang.Runtime就是經典的單例模式(餓漢式)
從以下原始碼可以看出：

單例模式注意事項和細節說明

1、單例模式保證了系統記憶體中該類只存在一個物件，節省了系統資源，對于一些需要頻繁創建銷毀的物件，使用單例模式可以提高系統性能
2、當想實體化一個單例類的時候，必須要記住使用相應的獲取物件的方法，而不是使用new

3、建議不要使用反射進行設計單例模式，因為反射可以暴力破壞單例模式

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

標籤：java

上一篇：【自我介紹】累了就看看自己的目標和規劃！！！

下一篇：Python爬蟲爬取資料

JAVA設計模式——單例模式八種方式

單例模式簡介：

單例模式優點:

應用場景：

單例設計模式的八種方式:

1、餓漢式（靜態常量）

2、餓漢式（靜態代碼塊）

3、懶漢式（執行緒不安全）

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

5、懶漢式（執行緒安全，同步代碼塊）

6、雙重檢查（推薦使用）

7、靜態內部類(推薦使用)

8、列舉（推薦使用）

單例模式在JDK應用的原始碼分析

單例模式注意事項和細節說明