设计模式：单例模式

一.

　　单例模式指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。

二.饿汉模式

public class HungrySingleton {

    private HungrySingleton(){}

    private final static HungrySingleton HUNGRY_SINGLETON ;

    static {
        HUNGRY_SINGLETON = new HungrySingleton();
    }

    public static HungrySingleton getInstance(){
        return HUNGRY_SINGLETON;
    }
}

　饿汉式是指类的被加载的时候，就被初始化，并创建单例对象，不会存在访问安全问题。

缺点：所有的饿汉单例对象都会在项目启动时初始化，会造成大量内存资源浪费。

三.懒汉模式

（1）考虑到饿汉模式的缺点后，加以修改，在类被调用的时候，才初始化。

public class LazySimpleSingleton {

    private LazySimpleSingleton(){}

    private static LazySimpleSingleton LAZY_SIMPLE_SINGLETON = null;

    public static LazySimpleSingleton getIn，stance(){
        if(null==LAZY_SIMPLE_SINGLETON){
            LAZY_SIMPLE_SINGLETON = new LazySimpleSingleton();
            return LAZY_SIMPLE_SINGLETON;
        }
        return LAZY_SIMPLE_SINGLETON;
    }
}

　但是会带来一个新的问题，就是在多线程环境下，有两个线程同一时间进入getInstance方法，同事满足null=LAZY_SIMPLE_SINGLETON时，会创建两个对象，然后后创建的会覆盖先创建的单例对象。

考虑到这个问题后，进一步优化，使用synchronized关键字，给方法加锁。

public class LazySimpleSingleton {

    private LazySimpleSingleton(){}

    private static LazySimpleSingleton LAZY_SIMPLE_SINGLETON = null;

    public synchronized static LazySimpleSingleton getInstance(){
        if(null==LAZY_SIMPLE_SINGLETON){
            LAZY_SIMPLE_SINGLETON = new LazySimpleSingleton();
            return LAZY_SIMPLE_SINGLETON;
        }
        return LAZY_SIMPLE_SINGLETON;
    }
}

　当一个线程调用getInstance方法时，另一个线程也调用该方法，会出现阻塞，直到第一个线程执行结束，才继续调用，完美解决了线程安全问题。

出现新的问题：

如果线程数量暴增，给getInstatnce加锁，只有一个线程运行该方法，其他线程全部阻塞等待，用户体验不好。新的解决方案--双重检查锁单例写法应运而生。

（2）双重检查锁单例  (进门安检一次，闸口再检查一次)

改造一下写法：

public class LazyDoubleSingleton {
    private volatile static LazyDoubleSingleton instance;
    private LazyDoubleSingleton(){}

    public static LazyDoubleSingleton getInstance(){
        synchronized (LazyDoubleSingleton.class){
            if(null==instance){
                instance = new LazyDoubleSingleton();
            }
        }
        return instance;
    }
}

　这样的写法，其实和上一种写法差不多，都会造成大量线程阻塞。那如果把if条件往上升一级呢，先判断，再加锁。

public class LazyDoubleSingleton {
    private volatile static LazyDoubleSingleton instance;
    private LazyDoubleSingleton(){}

    public static LazyDoubleSingleton getInstance(){
        if(null==instance){
            synchronized (LazyDoubleSingleton.class){
                instance = new LazyDoubleSingleton();
            }
        }
        return instance;
    }
}

　经过此次修改后，还是会出现线程安全问题。

因为当两个线程同事满足null==instance条件后，会执行sychronized代码块的代码，该对象还是会被创建两次。

再优化一下，我们在sychronized代码块中再进行对象的非空检查，这样该对象就不会被创建两次。

public class LazyDoubleSingleton {
    private volatile static LazyDoubleSingleton instance;
    private LazyDoubleSingleton(){}

    public static LazyDoubleSingleton getInstance(){
        //检查是否要阻塞
        if(null==instance){
            synchronized (LazyDoubleSingleton.class){
                //检查是否要创建对象
                if(null==instance){
                    instance = new LazyDoubleSingleton();
                }

            }
        }
        return instance;
    }
}

四.静态内部类单例的写法

  双重检查锁单例这种方式虽然解决了线程安全问题和性能问题，但是用到了sychronized总是要上锁，对性能还是有一些影响。我们可以采用静态内部类的方式进行优化。

/**
 * @Author wen.jie
 * @Description 使用InnerClassSingleton类时,会默认先初始化内部类，如果没有使用，则内部类不初始化
 **/
public class InnerClassSingleton {

    private InnerClassSingleton(){}

    public static InnerClassSingleton getInstance(){
        return InnerClass.INNER_CLASS_SINGLETON;
    }

    private static class InnerClass{
        private static final InnerClassSingleton INNER_CLASS_SINGLETON = new InnerClassSingleton();
    }
}

　这种方式兼顾了饿汉单例写法的内存浪费问题和sychronized的性能问题，内部类一定要在方法调用之前就被初始化，巧妙的避开了线程安全问题。静态内部类单例写法真的完美了吗？

如果我们用反射强行创建对象呢？

public static void main(String[] args) {
        try {
            Constructor<InnerClassSingleton> constructor = InnerClassSingleton.class.getDeclaredConstructor(null);
            constructor.setAccessible(true);

            InnerClassSingleton o1 = constructor.newInstance();
            InnerClassSingleton o2 = constructor.newInstance();

            System.out.println(o1==o2);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

　

发现创建了两个不同的实例。优化方法，在构造器中，进行判断。

public class InnerClassSingleton {

    private InnerClassSingleton(){
        if(InnerClass.INNER_CLASS_SINGLETON!=null){
            throw new RuntimeException("不允许创建多个实例");
        }
    }

    public static InnerClassSingleton getInstance(){
        return InnerClass.INNER_CLASS_SINGLETON;
    }

    private static class InnerClass{
        private static final InnerClassSingleton INNER_CLASS_SINGLETON = new InnerClassSingleton();
    }
}

　当我们再用反射去创建对象时，就会抛出异常。

 但这种写法值得斟酌，在构造器中抛出异常，不够优雅，有没有比静态内部类更优雅的单例写法呢？

 五.枚举式单例写法（jdk1.5以后）

标准写法：

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;
    }
}

 这种写法更加简洁，无偿提供序列化机制，绝对防止多次实例化，即使是在面对复杂序列化或者反射攻击的时候。虽然这种方法还没有广泛采用，但是单元素的枚举类型已经成为实现单例的最佳方法。（Effective Java原文）

下面对其测试：

对该单例对象进行序列化和反序列化测试

public static void main(String[] args) {
    try {
        EnumSingleton instance1 = null;

        EnumSingleton instance2 = EnumSingleton.getInstance();
        instance2.setData(new Object());

        FileOutputStream fos = new FileOutputStream("EnumSingleton.dat");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(instance2);
        oos.flush();
        oos.close();

        FileInputStream fis = new FileInputStream("EnumSingleton.dat");
        ObjectInputStream ois = new ObjectInputStream(fis);
        instance1 = (EnumSingleton)ois.readObject();
        System.out.println(instance1.getData());
        System.out.println(instance2.getData());
        System.out.println(instance1.getData()==instance2.getData());
    } catch (IOException | ClassNotFoundException e) {
        e.printStackTrace();
    }
}

　测试结果：

六.反序列化破坏单例模式

反序列化会从磁盘文件中读取对象，转为内存对象，反序列化的对象会重新分配内存，如果反序列化的对象是单例对象，则违背了单例模式的初衷。

下面对之前写过的双重检查锁单例对象进行序列化和反序列化（先实现Serializable接口）：

    public static void main(String[] args) {
        try {
            LazyDoubleSingleton instance1 = null;
            LazyDoubleSingleton instance2 = LazyDoubleSingleton.getInstance();
            FileOutputStream fos = new FileOutputStream("LazyDoubleSingleton.dat");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(instance2);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("LazyDoubleSingleton.dat");
            ObjectInputStream ois = new ObjectInputStream(fis);
            instance1 = (LazyDoubleSingleton)ois.readObject();
            System.out.println(instance1==instance2);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

　结果：

 那我们如何保证序列化的情况下也能够实现单例模式呢？

其实只需要在单例对象中增加一个readResolve()方法（注意返回值必须是Object类型，不能是单例对象类型）：

public class LazyDoubleSingleton implements Serializable {
    private volatile static LazyDoubleSingleton instance;
    private LazyDoubleSingleton(){}

    public static LazyDoubleSingleton getInstance(){
        //检查是否要阻塞
        if(null==instance){
            synchronized (LazyDoubleSingleton.class){
                //检查是否要创建对象
                if(null==instance){
                    instance = new LazyDoubleSingleton();
                }

            }
        }
        return instance;
    }

    private Object readResolve(){
        return instance;
    }
}

　再看运行结果，就是true了

 具体原理是在readObject方法中判断了反序列化的对象中是否有无参的readResolve()方法（jdk源码中）。