設計模式之單例模式

餓漢式(靜態變數)

class Singleton1{
    //1.構造器私有化
    private Singleton1() {
    }
    private static final  Singleton1 singleton = new Singleton1();
    public static Singleton1 getInstance(){
        return singleton;
    }
}

優點：安全

缺點：可能造成記憶體浪費

餓漢式(靜態程式碼塊)

class Singleton2{
    //構造器私有化
    private Singleton2() {
    }
    private static Singleton2 singleton2;
    static{
        //在靜態程式碼塊中完成初始化
        singleton2 = new Singleton2();
    }
    public static  Singleton2 getInstance(){
        return singleton2;
    }
}
 

優缺點和上面一樣

懶漢式(執行緒不安全)

/**
 * 懶漢式(執行緒不安全)
 */
public class TestSingleton3 {
    public static void main(String[] args) {
        for (int i = 0; i < 1000; i++) {
            new Thread(() ->{
                System.out.println(Thread.currentThread().getName()+"@@"+Singleton3.getInstance().hashCode());
            },String.valueOf(i)).start();
        }
    }
}
class Singleton3{
    //構造器私有
    private Singleton3() {
    }
    private static Singleton3 singleton3;
    public static Singleton3 getInstance(){
        if(singleton3==null)
            singleton3 = new Singleton3();
        return singleton3;
    }
}
 

優點：起到了懶載入的效果，但只能在單執行緒下使用

缺點：多執行緒下執行緒不安全

懶漢式(同步方法或同步程式碼塊)

這裡只演示同步方法

class Singleton4 {
    //構造器私有化
    private Singleton4() {
    }
    private static Singleton4 singleton4;
    public static synchronized Singleton4 getInstance() {
        if (singleton4 == null)
            singleton4 = new Singleton4();
        return singleton4;
    }
}
 

優點：多執行緒下安全

缺點：效率低下

DCL

class Singleton5{
    //構造器私有化
    private Singleton5() {
    }
    //注意要加volatile關鍵字
    //volatile關鍵字在這裡的作用主要是保證可見性
    private static volatile Singleton5 singleton5;
    public static Singleton5 getInstance(){
        if (singleton5==null){
            synchronized (Singleton5.class){
                if(singleton5==null)
                    singleton5 = new Singleton5();
            }
        }
        return singleton5;
    }
}

優點：執行緒安全，延遲載入，效率較高

在這裡說一下volatile的作用

volatile的三大作用：保證可見性，不保證原子性，禁止指令重排

筆者認為volatile在這裡的作用主要是保證可見性，當一個執行緒進入到同步程式碼塊中，它建立完物件後，應立刻對其它執行緒可見。volatile的

作用就是當被volatile修飾的變數發生變化時，其結果會立刻強制被刷回到主存中，而其它執行緒會通過匯流排嗅探機制和快取一致性協議得知

自己快取中的資料已經失效，會等待快取行對應的主存地址被更新之後，再去讀取對應的主存中的新值。

當然，這只是筆者認為的，網上的答案也是眾說紛壇。筆者的答案只能作為參考，如有不對，請告知於我。

靜態內部類

class Singleton6{
    //構造器私有化
    private Singleton6() {
    }
    //因為外部類載入的時候不會觸發靜態內部類的載入
    //並且類的靜態屬性只會在類第一次被載入的時候初始化，
    //所以在這裡，JVM幫助我們保證了現成的安全性，在類進行初始化時，別的執行緒是無法進入的。
    private static class InnerSingleton{
        public static final Singleton6 INSTANCE = new Singleton6();
    }
    public static Singleton6 getInstance(){
        return InnerSingleton.INSTANCE;
    }
}

優點：執行緒安全，延遲載入，效率較高

列舉

enum  Singleton7{
    INSTANCE;
    public void method(){
        System.out.println("你好呀!!!");
    }
}

優點：執行緒安全，可以防止反序列化重新建立新的物件，推薦使用。