写单例模式以及防止反射破坏

一、为何要单例？

优点：

1.由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。
2.由于单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决（在Java EE中采用单例模式时需要注意JVM垃圾回收机制）
3.单例模式可以避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作
4.单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理
 

缺点：

1.单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。单例模式为什么不能增加接口呢？因为接口对单例模式是没有任何意义的，它要求“自行实例化”，并且提供单一实例、接口或抽象类是不可能被实例化的。当然，在特殊情况下，单例模式可以实现接口、被继承等，需要在系统开发中根据环境判断单例模式对测试是不利的。在并行开发环境中，如果单例模式没有完成，是不能进行测试的，没有接口也不能使用mock的方式虚拟一个对象
2.单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关心它是否是单例的，是不是要单例取决于环境，单例模式把“要单例”和业务逻辑融合在一个类中
 

 

二、代码编写

1.饿汉式

在类加载的时候就创建好单例。

public class Hungry {

    //第一要素必须私有构造函数，才不能被随意New
    private Hungry(){

    }

    //2.在类加载的时候，就直接创建
    private final static Hungry instance = new Hungry();

    //3.采用方法的形式去取，防止成员实例被修改。
    public static Hungry getInstance(){
        return instance;
    }

}

测试：

    Hungry hungry = Hungry.getInstance();
        Hungry hungry1 =  Hungry.getInstance();
        System.out.println(hungry == hungry1);
        //结果为true

2.懒汉式

等到要的时候才会去加载，2+1

public class Lazy {

    //1.私有构造函数
    private Lazy(){

    }

    //2.私有对象
    private volatile static Lazy instance = null;

    //3.获得getStance方法
    public static Lazy getInstance(){
        if(instance == null){
            synchronized (Lazy.class){
                if(instance == null){
                    instance = new Lazy();
                }
            }
        }
        return instance;
    }

}

sychronized+第二个if:防止多线程创建多个线程

都进入了锁之前的地方，所以第一个线程创建完后，第二个线程跟进去继续又创建。所以就会有两个因此我们要在锁代码块内部还要添加一个 是否创立过。

volatile:防止指令重排，返回没有初始化的对象

这样还不够完美。因为涉及到指令重排。

Javap 看反汇编看具体指令执行。 New的操作会执行这三部操作

编译器 JIT cpu 可能会让我们指令重排

成下面这样

比如T1进去后执行到2(把内存引用赋值给变量)，然后这个时候T3线程进来发现实例引用不为null，然后就直接返回。但是这次返回的是没有被初始化的实例。

怎么解决呢  在这个instance的变量加上volatile就不会重排序了

三、单例会被反射破坏以及解决办法

反射破坏单例的代码：

   public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //懒汉式
        Lazy lazyInstance = Lazy.getInstance();
        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor(null);
        //要将设有成员设置为可见，否则这边无法获取私有对象的
        declaredConstructor.setAccessible(true);
        Lazy lazyInstance2 = declaredConstructor.newInstance();
        System.out.println(lazyInstance  == lazyInstance2 );

        //饥汉式
        Hungry hungryInstance = Hungry.getInstance();
        Constructor<Hungry> hungryDeclaredConstructor1 = Hungry.class.getDeclaredConstructor(null);
        hungryDeclaredConstructor1.setAccessible(true);
        Hungry hungryInstance2 = hungryDeclaredConstructor1.newInstance();
        System.out.println(hungryInstance == hungryInstance2);

    }

运行结果：

这里可以看出饥汉和懒汉都会单例不安全。

饿汉解决方式：

对于饿汉的解决方式，是在私有构造函数加一个if判断即可。

public class Hungry {

    //第一要素必须私有构造函数，才不能被随意New
    private Hungry(){
         if(instance == null){

         }else {
             throw new IllegalArgumentException("单例已经创建");
         }
    }

    //2.在类加载的时候，就直接创建
    private static Hungry instance = new Hungry();

    //3.采用方法的形式去取，防止成员实例被修改。
    public static Hungry getInstance(){
        return instance;
    }

}

 运行结果：

懒汉解决方式(无法解决)：

懒汉无法解决被反射破坏单例的。

懒汉采用饿汉式的方法却是不行的。因为我们只要通过反射获得构造器后，我们就不需要再次进入私有构造函数了，只要第一次进行了构造那么，之后就可以直接New实例。

public class Lazy {

    //1.私有构造函数
    private Lazy(){
        if(instance != null) {
            throw new IllegalArgumentException("单例已经创建");
        }
    }

    //2.私有对象
    private volatile static Lazy instance = null;

    //3.获得getStance方法
    public static Lazy getInstance(){
        if(instance == null){
            synchronized (Lazy.class){
                if(instance == null){
                    instance = new Lazy();
                }
            }
        }
        return instance;
    }

}

测试代码：

     //懒汉式
        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor();
        //要将设有成员设置为可见，否则这边无法获取私有对象的
        declaredConstructor.setAccessible(true);
        Lazy lazyInstance2 = declaredConstructor.newInstance();
        Lazy lazyInstance3 = declaredConstructor.newInstance();
        Lazy lazyInstance = Lazy.getInstance();
        System.out.println(lazyInstance);
        System.out.println(lazyInstance2);
        System.out.println(lazyInstance3);
        System.out.println(lazyInstance3  == lazyInstance2);

结果：

同一个构造器的可以New出不同的实例。但是如果先进行调用静态方法New的话，那么就会抛出异常了，因为创建构造器的时候instance就不是Null了。

网上还有信号量的方式： 采用信号量去控制调用次数，但是反射既然能改变私有成员，那么这个信号量也可以改变，所以这里也无法解决。

四、饿汉和懒汉的优劣势

1、时间和空间

比较上面两种写法：懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间。

饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

2.线程安全

饿汉不存在线程安全，懒汉存在线程安全问题

五、枚举单例可以解决被反射和序列化破坏

直接上代码~ 枚举类中有我们另外想要的实现的类，通过单例去创建我们的实现类。

public enum  EnumSingle {

    INSTANCE;

    private EnumSingleImp enumSingleImp  = null;

    //返回自己需要的对象
    public EnumSingleImp getInstance(){
        return enumSingleImp;
    }

    //私有构造自己想要用的类
    private EnumSingle(){
        enumSingleImp = new EnumSingleImp();
    }


}
//我们自己的实现类
class  EnumSingleImp{
}

测试：

   //枚举形式
        EnumSingleImp instance = EnumSingle.INSTANCE.getInstance();
        EnumSingleImp instance2 = EnumSingle.INSTANCE.getInstance();
        System.out.println(instance == instance2);
        Constructor<EnumSingle> declaredConstructor1 = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor1.setAccessible(true);
        //直接报错无法通过反射获得枚举
        EnumSingle enumSingle = declaredConstructor1.newInstance();

结果：

创建两个对象的是一样的。

也不准进行反射破坏。

Java规范字规定，每个枚举类型及其定义的枚举变量在JVM中都是唯一的，因此在枚举类型的序列化和反序列化上，Java做了特殊的规定。序列化的时候只将INSTANCE这个名称输出，反序列化的时候再通过这个名称，查找对应的枚举类型，因此反序列化后的实例也会和之前被序列化的对象实例相同。