Java單例模式的5種實現方式

1.餓漢式、不支持併發：

package com.ou;

//餓漢式
public class Singleton1 {
    private Singleton1() {
    }
    private static Singleton1 instance = new Singleton1();
    
    public static Singleton1 getInstance(){
        return instance;
    }

}

 此模式只能運行在單線程下，且類在載入時就已經創建好了實例，不管需不需要用。

2.懶漢式、不支持併發：

package com.ou;

//懶漢式、不支持多併發
public class Singleton2 {
    private Singleton2() {
    }
    private static Singleton2 instance = null;
    public static Singleton2 getInstance(){
        if (instance == null){
            instance = new Singleton2();
        }
        return instance;
    }

}

  此模式只能運行在單線程下，在調用獲取實例的方法時才創建實例。

3.懶漢式、支持併發、synchronized：

package com.ou;

//懶漢式、支持多併發、效率低
public class Singleton3 {
    private Singleton3() {
    }
    private static Singleton3 instance = null;
    public synchronized static Singleton3 getInstance(){
        if (instance == null){
            instance = new Singleton3();
        }
        return instance;
    }

}

synchronized 鎖住了整個方法，當有多個線程需要訪問方法時，不管實例有沒有創建，都會要排隊等待才能拿到實例，效率低。
需要改進：只有第一次創建實例時才需要鎖，其他時候不需要加鎖。

4.雙重檢查鎖 、volatile（常用）：

package com.ou;

//double checked locking、支持多併發、效率高、添加volatile關鍵字
public class Singleton4 {
    private Singleton4() {
    }
    private volatile static Singleton4 instance = null;
    public static Singleton4 getInstance(){
        if (instance == null){//1
            synchronized (Singleton4.class) {
                if (instance == null)//2
                    instance = new Singleton4();
            }
        }
        return instance;
    }
}

volatile 關鍵字保證了記憶體可見性，所有線程都會去主存中取數據而不是線上程的緩存中取，保證了數據的更新能實時地對任何線程可見。
假如有兩個線程同時到達了1，它們都去創建實例，這時候如果沒有第二次判斷，就會多次創建實例了。二次判斷保證了多線程下只創建一個實例。

5.靜態私有內部類（常用）：

package com.ou;

//靜態私有內部類、支持多併發、效率高、
public class Singleton5 {
    private Singleton5() {
    }
    private static class SingletonHolder{
        private static Singleton5 instance = new Singleton5();
    }
    public static Singleton5 getInstance(){
        return SingletonHolder.instance;
    }
}

內部類的好處：內部類在被調用的時候才實例化其靜態成員變數，高！