单例模式的升级玩法

1.DCL 双检索模式的懒汉单例模式

1.1 第一种

public class SingleDemo {

    private volatile static SingleDemo singleDemo;
    private SingleDemo(){
        //System.out.println(Thread.currentThread().getName());
    }

    public static SingleDemo getInstance(){
        if(singleDemo == null){
            synchronized (SingleDemo.class){
                if(singleDemo == null){
                    singleDemo = new SingleDemo();  
                   /* 1.分配内存空间
                    * 2.执行构造方法，初始化对象
                    * 3.把这个对象指向内存空间
                    * */          
                }
            }
        }
        return singleDemo;
    }
}

• new SingleDemo()：不是一个原子性操作，所以有可能，出现多个对象的可能
• private static SingleDemo singleDemo 得加上volatile关键字

注意：上面依然不是绝对安全的，因为用反射依然可以，创建多个不同对象

2.第二种升级版

public class SingleDemo2 {
    private volatile static SingleDemo2 singleDemo2;

    private SingleDemo2(){

        synchronized (Singleton2.class){
            if(singleDemo2!=null){
                throw new RuntimeException("不能通过反射来构造单例");
            }
        }

    }
    public static SingleDemo2 getInstance(){
        if(singleDemo2 == null){
            synchronized (Singleton2.class){
                if ((singleDemo2==null)){
                    singleDemo2 = new SingleDemo2();
                }
            }
        }

        return singleDemo2;
    }
}
class Test2{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, InterruptedException {
        //SingleDemo2 singleDemo2 = SingleDemo2.getInstance();
        Constructor<SingleDemo2> singleDemo2Constructor = SingleDemo2.class.getDeclaredConstructor();
        singleDemo2Constructor.setAccessible(true);
        SingleDemo2 singleDemo21 = singleDemo2Constructor.newInstance();
        TimeUnit.SECONDS.sleep(5);
        SingleDemo2 singleDemo22 = singleDemo2Constructor.newInstance();
        //通过再构造方法里判断是否为null，防止反射创建对象,但是，若两种都是由构造器生成的，还是不管用
        //System.out.println(singleDemo2);
        System.out.println(singleDemo21);
        System.out.println(singleDemo22);
    }
}

• 构造方法加锁，加判断条件
• 但是，这种方法，依然挡不住，用反射构造方法，创建多个对象，依然不安全

1.3 再升级，采用枚举

public enum SingleEnum {
    Instance;

    public SingleEnum getInstance(){
        return Instance;
    }
}

class Test3{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //采用枚举之后，构造方法也发生了改变，变成了，有参构造方法
        //可以通过jad -sjava xxx.class ，查看源码
        //注意，jd-gui反编译和jad反编译回来是不一样的
        Constructor<SingleEnum> constructor = SingleEnum.class.getDeclaredConstructor(String.class,int.class);
        constructor.setAccessible(true);

        SingleEnum singleEnum1 = constructor.newInstance();
        SingleEnum singleEnum2 = constructor.newInstance();

        System.out.println(singleEnum1);
        System.out.println(singleEnum2);
    }
}

• 采用枚举的方式，成功，阻止反射创建对象
• 查看源码