Java 單例模式

今天思考了一下單例模式,普通的懶漢模式會導致執行緒的不安全

public class Demo{
    private Demo(){
    }
    private static Demo instance;
    public static Demo getInstance (){
        if(instance==null){
            instance = new Demo();
        }
        return instance;
    }
}

怎樣體現出來的執行緒不安全呢? 我們可以寫個測試程式看看

public class Test {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                Demo d1 = Demo.getInstance();
                System.out.println(d1);
            }
        };

        Thread t2 = new Thread(){
            @Override
            public
 
 void run() {
                Demo d2 = Demo.getInstance();
                System.out.println(d2);
            }
        };
        t1.start();
        t2.start();
    }
}

這裡寫了兩個執行緒,同時執行出來的結果如下:

從執行的結果可以看出來這樣的結果是不安全的,無法滿足單例模式的要求,這是我們就要加鎖,於是引入如下的模式

1.雙檢索懶漢

//雙檢索懶漢模式
public class Demo7 {

    private
 
 static volatile Demo7 instance;

    private Demo7() {

    }
    public static Demo7 getInstance() {
        //粗選
        if (instance == null) {
            synchronized (Demo7.class) {
                //細選
                if (instance == null) {
                    instance = new Demo7();
                }
            }
        }
        return instance;
    }

}

2.

//懶漢模式靜態內部類
public class Demo8 {
    private Demo8(){

    }
    public static Demo8 getInstance(){
        return InstanceHolder.instance;
    }

    public static class InstanceHolder{
        static Demo8 instance = new Demo8();
    }
}

3.

//餓漢模式
public class Demo9 {
    private Demo9(){

    }
    static Demo9 instance = new Demo9();
    public static Demo9 getInstance(){
        return instance;
    }
}