深入理解单例模式

单例模式是设计模式中最常见的一种，也是大家最熟悉的一种，可谓是信手沾来，最近在学习中学习到了以往未曾考虑到的东西，就此记录，以免忘却。

饿汉式

话不多说，上代码

package com.zhouyou;

//饿汉式单例
//耗费内存
public class Hungry {
    private Hungry(){
    }
    private final static Hungry HUNGRY =  new Hungry();
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

懒汉式以及引发的问题思考及解决

package com.zhouyou;

//懒汉式
public class LazyMan {

    private LazyMan(){
    }
    
    private static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if(lazyMan == null){
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }
    //单线程下单例正常，多线程下并发错误

}

如果是多线程，那么会导致异常出现，如下图

那么我们应该如何解决这个问题呢？答案是加锁
此为DCL双检锁

private volatile static LazyMan lazyMan;
if (lazyMan == null) {
            synchronized (LazyMan.class) {
            //但是由于不是原子性操作，会分配内存空间，cpu进行处理，有可能会发生倒序乱序等，所以需要加入
			//volatile  防止指令重排
                if (lazyMan == null) {
                    lazyMan = new LazyMan();
                }
            }
        }

还有另外一种模式，静态内部类 这里就不在多说了
下面我们来看看反射是如何破坏单例模式的

//反射破坏单例
    public static void main(String[] args) throws Exception{
        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        //无视私有构造器
        constructor.setAccessible(true);
        LazyMan instance1 = constructor.newInstance();
        System.out.println(instance);
        System.out.println(instance1);
    }
    //com.zhouyou.LazyMan@1b6d3586
	//com.zhouyou.LazyMan@4554617c

结果显示经过反射破坏后已经不是同一个对象了
初步解决方法很多，但是不能彻底解决问题，

• 加synchronized锁
  • 如果一个对象是new 一个是反射创建能够有效检测，但是如果2个都是反射创建的对象仍然无法解决
• 优化 = >

  `private static boolean zhouyou = false;
    private LazyMan() {
        synchronized (LazyMan.class){
            if(zhouyou == false){
                zhouyou = true;
            }else {
                throw new RuntimeException("不要破坏反射");
            }
        }
    }`

• 自定义值进行标志，可以有效检测，但是如果用反编译等方式获取到 ‘zhouyou’ 的 参数名，那么也可以通过反射强制改变，如下代码

Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        //无视私有构造器
        Field zhouyou = LazyMan.class.getDeclaredField("zhouyou");
        constructor.setAccessible(true);
        LazyMan instance1 = constructor.newInstance();
        zhouyou.set(instance1,false);
        LazyMan instance2 = constructor.newInstance();
        System.out.println(instance2);
        System.out.println(instance1);

那么最好的办法是什么呢， 在newInstance源码中已经为我们指出了，如果为枚举类型时i，会抛出异常，可以有效的解决反射带来的破坏单例

if ((clazz.getModifiers() & Modifier.ENUM) != 0)
            throw new IllegalArgumentException("Cannot reflectively create enum objects");

而深入枚举类会发现以下流程：
继承Enum枚举类 ，并且用专业反编译软件编译class文件能发现其实枚举并不是无参构造， 而是有参构造，这里就不展示过程了
代码如下

	private EnumSingle(String s,int i){
        super(s,i);
    }

如果想用反射获取枚举的类型并进行成功抛出源码里面的错误，需要进行有参设置，牢记枚举此特性

Constructor<EnumSingle> constructor = EnumSingle.class.getDeclaredConstructor(String.calss,int.class);

萌新码农一枚，才疏学浅，如有不足，忘指正共勉!