单例模式最佳实践及破环单例的几种可能方式及解决方案

单例模式最佳实践及破环单例的几种可能方式及解决方案

1、懒汉式单例模式最佳实践
使用内部类，在内部类中创建对象，避免了使用锁造成的性能消耗。
原理：内部类在外部类的方法调用之前加载。且只加载一次
如下：
public class LazyInnerClassSingleton {
public LazyInnerClassSingleton(){
}

public static final LazyInnerClassSingleton getInstance(){
    return LazyHolder.LAZY;
}

/**
 * 调用方法前先加载内部类，加载类不会出现线程安全
 */
private static class LazyHolder{
    private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    
}

}
2、反射破坏单例的解决
要是必须使用内部类去创建对象。
其次在外部类的构造方法中，判断全局的单例变量是否不为null，因为在调用外部的构造方法前，会先加载内部类，所以反射会报错。这种方式会导致该类无法被反射。
public class LazyInnerClassSingleton {
public LazyInnerClassSingleton(){
if (LazyHolder.LAZY != null) {
throw new RuntimeException(“不允许创建多个实例”);
}

}

public static final LazyInnerClassSingleton getInstance(){
    return LazyHolder.LAZY;
}

/**
 * 调用方法前先加载内部类，加载类不会出现线程安全
 */
private static class LazyHolder{
    private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    
}

}
3、序列化破坏单例的解决方案
一个对象创建好之后，将对象序列化写到磁盘，再从磁盘读取对象，反序列化到内存，那么就会生成一个新的对象，破坏了单例模式。
解决方式:
在类中添加 readResolve()方法，返回我们已经创建的实例。
private Object readResolve() {
return instance;
}
原理：
ObjectInputStream.readObject()方法在反序列化时，通过反射，寻找一个名为readResolve的无参的方法，执行该方法，如果传回一个对象，那么ObjectInputStream.readObject()就返回该对象，不然就返回反序列化生成的对象。
这种方式，虽然返回的是我们创建过的单例对象，但是实际上会在内存中生成了一个对象，只是没有返回使用到而已，这种方式有导致内存分配开销增大的风险（实际上无所谓），就算不是单例，也会生成一个对象，而且还存在引用，这种都不会存在引用，更容易被垃圾回收机制释放内存。
4、自定义类加载器破坏单例
不同的类加载器，会重复加载一个类，目前没有办法阻止不同类加载器，重复创建一个类。但是不同的类加载器，有不同的命名空间，生成不同的class对象，表面上看，是生成了两个对象，但是这两个对象属于不同的class对象，且无法相互强转，不算是两个相同的实例。
代码示例：
public class MultipleClassLoad {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
MyCustomLoad myCustomLoad = new MyCustomLoad();
Class<?> aClass = myCustomLoad.loadClass(“wjh.designmodel.单例模式.LoadClassOne”,false);

    Object o =  aClass.newInstance();

// Object singleton = o.getSingleton();
// System.out.println(singleton);
Method getSingleton = o.getClass().getMethod(“getSingleton”);
Object invoke = getSingleton.invoke(o);
Method print = invoke.getClass().getMethod(“print”);
print.invoke(invoke);

    LoadClassTwo two = new LoadClassTwo();
    Object singleton1 = two.getSingleton();
    Method da = singleton1.getClass().getMethod("print");
    da.invoke(singleton1);
}

}

5、枚举式单例模式
代码示例如下：
public enum EnumSingleton {
INSTANCE;
// 存储的单例对象
private Object data;

public void setData(Object data) {
    this.data = data;
}

public Object getData() {
    return data;
}

public static EnumSingleton getInstance() {
    return INSTANCE;
}

}
这种方式天然组织了反射和序列化破坏单例的可能性，不需要自己额外做其它操作，原因如下：
1、枚举类无法被反射。
2、发序列化时，readObject（）方法中，天然主动根据类名和对象类找到唯一的枚举对象，该枚举类加载过的话，返回已存在的枚举对象。没有加载过的话，此时加载枚举类，在加载过程中，会给INSTANCE赋值，创建枚举对象。