写单例模式以及防止反射破坏
一、为何要单例？
优点：
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);
//结果为true2.懒汉式
等到要的时候才会去加载，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 declaredConstructor = Lazy.class.getDeclaredConstructor(null);
//要将设有成员设置为可见，否则这边无法获取私有对象的
declaredConstructor.setAccessible(true);
Lazy lazyInstance2 = declaredConstructor.newInstance();
System.out.println(lazyInstance == lazyInstance2 );
//饥汉式
Hungry hungryInstance = Hungry.getInstance();
Constructor 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 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 declaredConstructor1 = EnumSingle.class.getDeclaredConstructor(String.class, int.class);
declaredConstructor1.setAccessible(true);
//直接报错无法通过反射获得枚举
EnumSingle enumSingle = declaredConstructor1.newInstance(); 结果：
创建两个对象的是一样的。
也不准进行反射破坏。
Java规范字规定，每个枚举类型及其定义的枚举变量在JVM中都是唯一的，因此在枚举类型的序列化和反序列化上，Java做了特殊的规定。序列化的时候只将INSTANCE这个名称输出，反序列化的时候再通过这个名称，查找对应的枚举类型，因此反序列化后的实例也会和之前被序列化的对象实例相同。