单例模式

单例模式定义：不管在什么场景下只能生成一个类实例；

单例模式主要注意以下几个问题：

1. 线程安全问题；解决方法：sychronized、静态内部类、双重检测时用volatile；

2. 反射破坏单例模式；解决方法：单例构造函数中加对象非空校验；

3. 序列化反序列化破坏单例模式；解决方法：重写readResolve方法或者用枚举单例；

懒汉和饿汉的本质区别，就是实例化对象的时机，即是什么时候将对象创建起来

饿汉式：在加载类的时候就创建单例对象，所以调用时肯定线程安全
缺点是：不管用不用，都会创建对象，消耗内存对象，可能造成浪费（占着茅坑不拉屎）
@ThreadSafe
public class Hungry {
　　private Hungry() {}
　　private static final Hungry instance = new Hungry();
　　public static Hungry getInstance() { return instance; } 
}

懒汉式单例模式建议使用静态内部类，JVM能够确保线程安全问题，但是要解决反射攻击和序列化反序列化攻击，还得通过代码来实现：

解决反射攻击的问题：需要在构造函数中控制私有静态成员变量的重复创建；

解决序列化反序列化攻击的问题：重写readResolve()方法

/**
 * Created by marcopan on 2018/9/14.
 * 有反射攻击和序列化攻击的问题
 *
 * 反射攻击解决方法，在构造函数中判断单例是否为空
 */
public class LazySingleton implements Serializable {
    private LazySingleton() {
        // 防止通过反射来破坏单例
        if (LazySingletonHolder.singleton != null) {
            throw new RuntimeException("不允许创建多个实例");
        }
    }

    public static final LazySingleton getInstance() {
        return LazySingletonHolder.singleton;
    }

    private static class LazySingletonHolder {
        private static final LazySingleton singleton = new LazySingleton();
    }

//    public static void main(String[] args) {
//        try {
//            //很无聊的情况下，进行破坏
//            Class<?> clazz = LazySingleton.class;
//            //通过反射拿到私有的构造方法
//            Constructor c = clazz.getDeclaredConstructor(null);
//            //强制访问，强吻，不愿意也要吻
//            c.setAccessible(true);
//
//            //暴力初始化
//            Object o1 = c.newInstance();
//            //调用了两次构造方法，相当于new了两次,犯了原则性问题，
//            Object o2 = LazySingleton.getInstance();//c.newInstance();
//
//            System.out.println(o1 == o2);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
    
    private Object readResolve() {
        return LazySingletonHolder.singleton;
    }

    public static void main(String[] args) {
        try {
            LazySingleton instance1 = LazySingleton.getInstance();

            FileOutputStream fos = new FileOutputStream("EnumSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(instance1);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("EnumSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            LazySingleton instance2 = (LazySingleton) ois.readObject();
            ois.close();

            System.out.println(instance1 == instance2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

双重校验机制需要添加volatile关键字，防止指令重排序，双重校验机制同样无法解决反射攻击和序列化反序列化的问题。

public class RegisterSingleton {
    /** volatile防止指令重排序
     *  有反射和序列化攻击的问题
     */
    private volatile static RegisterSingleton lazy = null;

    private RegisterSingleton() {
    }

    public static RegisterSingleton getInstance() {
        if (lazy == null) {
            synchronized (RegisterSingleton.class) {
                if (lazy == null) {
                    lazy = new RegisterSingleton();
                    //1.分配内存给这个对象
                    //2.初始化对象
                    //3.设置lazy指向刚分配的内存地址
                    //4.初次访问对象
                }
            }
        }
        return lazy;
    }
}

枚举单例模式能够完美解决反射攻击和序列化反序列化的问题。

public enum EnumSingleton {

    INSTANCE;
    private Object data;

    public Object getData() {
        return data;
    }

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

    public static EnumSingleton getInstance() {
        return INSTANCE;
    }

    public static void main(String[] args) {
        try {
            EnumSingleton instance1 = EnumSingleton.getInstance();
            instance1.setData(new Object());

            FileOutputStream fos = new FileOutputStream("EnumSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(instance1);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("EnumSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            EnumSingleton instance2 = (EnumSingleton) ois.readObject();
            ois.close();

            System.out.println(instance1.getData());
            System.out.println(instance2.getData());
            System.out.println(instance1.getData() == instance2.getData());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

其中关于枚举的可以参考这篇文章，写得挺透彻的http://www.manongjc.com/article/1597.html

这里还要强调一点关于双重检查锁的情况，双重检查锁之所以是线程不安全的，原因在于CPU处理器会对指令进行重排序，有线程可能会拿到没有完成初始化的对象。双重检查锁要使用volatile变量避免双重检查锁线程不安全的问题