Java单例的一些思考

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;
    }
}