单例设计模式

一、单例模式的应用场景

单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并 提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛。 例如，国家主席、公司 CEO、部门经理等。在 J2EE 标准中，ServletContext、 ServletContextConfig 等；在 Spring 框架应用中 ApplicationContext；数据库的连接 池也都是单例形式。

二、单例模式的实现方式

1、饿汉式

饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，在线 程还没出现以前就是实例化了，不可能存在访问安全问题。 优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。 缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存，有可能占着茅 坑不拉屎。

Spring 中 IOC 容器 ApplicationContext 本身就是典型的饿汉式单例。

比较简单的一种写法:

//饿汉式单例
// 它是在类加载的时候就立即初始化，并且创建单例对象

    //优点：没有加任何的锁、执行效率比较高，
    //在用户体验上来说，比懒汉式更好
	//绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题

    //缺点：类加载的时候就初始化，不管你用还是不用，我都占着空间
    //浪费了内存，有可能占着茅坑不拉屎

    

public class HungrySingle {
    
     private static final HungrySingle hungrySingle=new HungrySingle();

    private HungrySingle(){
    }

    public static HungrySingle getInstance(){
        return hungrySingle;
    }
}

还有一种写法，是放在静态代码块中:

public class StaticHungrySingle {
    
    private static final StaticHungrySingle instance;
    
    static {
        instance = new StaticHungrySingle();
    }
    
    private StaticHungrySingle(){
    }
    
    public static StaticHungrySingle getInstance(){
        return  instance;
    }
}

2、懒汉式

懒汉式单例的特点是：被外部类调用的时候内部类才会加载，下面看懒汉式单例的简单：

//懒汉式单例
//在外部需要使用的时候才进行实例化
public class SimpleLazySingle {

    private SimpleLazySingle(){
    }

    //静态块，公共内存区域
    private static SimpleLazySingle instance=null;

    public static SimpleLazySingle getInstance(){
        if(instance==null){
            instance = new SimpleLazySingle();
        }

        return instance;
    }
}

这种写法虽然简单，但却存在很重的线程安全问题。在多线程下，会出现问题。

既然，有线程问题，那我们最先想到的解决办法即是加锁。

public class SimpleLazySingle {

    private SimpleLazySingle(){
    }

    private static SimpleLazySingle instance=null;

    public synchronized static SimpleLazySingle getInstance(){
        if(instance==null){
            instance = new SimpleLazySingle();
        }

        return instance;
    }
}

此种写法虽然可以解决线程安全问题，但是并发度不高，影响系统的性能。想要解决线程安全问题，加锁是避免不了，又想要提高一点性能，那只能是锁住的范围越小越好。于是，便有了下面这种双重检查的写法:

public class DoubleCheckSingle {

    private volatile static DoubleCheckSingle instance = null;

    private DoubleCheckSingle(){

    }

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

        return instance;
    }
}

但是，用到 synchronized 关键字，总归是要上锁，对程序性能还是存在一定影响的。难道就真的没有更好的方案吗？当然是有的。我们可以从类初始化角度来考虑，看下面的代码，采用静态内部类的方式：

public class StaticInnerSingle {

    private StaticInnerSingle(){
    }

    public static final StaticInnerSingle getInstance(){
        return LazyInstance.instance;
    }

    private static class LazyInstance{
        private static final StaticInnerSingle instance=new StaticInnerSingle();
    }
}

这种形式兼顾饿汉式的内存浪费，也兼顾 synchronized 性能问题。内部类一定是要在方法调用之前初始化，巧妙地避免了线程安全问题。

但是，用到synchronized关键字，总归是要上锁，对程序性能还是存在一定影响的。难道就真的没有更好的方案吗？当然是有的。我们可以从类初始化角度来考虑，看下面的代码，采用静态内部类的方式：

//懒汉式单例


//这种形式兼顾饿汉式的内存浪费，也兼顾synchronized性能问题
//完美地屏蔽了这两个缺点
public class LazyInnerClassSingleton {
    //默认使用LazyInnerClassGeneral的时候，会先初始化内部类
    //如果没使用的话，内部类是不加载的
    private LazyInnerClassSingleton(){
    }

    //每一个关键字都不是多余的
    //static 是为了使单例的空间共享
    //保证这个方法不会被重写，重载
    public static final LazyInnerClassSingleton getInstance(){
        //在返回结果以前，一定会先加载内部类
        return LazyHolder.LAZY;
    }

    //默认不加载
    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

静态内部类这种写法为什么既是线程安全的，又能够做到懒加载呢？

虚拟机会保证一个类的类构造器()在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的类构造器()，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。

特别需要注意的是，在这种情形下，其他线程虽然会被阻塞，但如果执行()方法的那条线程退出后，其他线程在唤醒之后不会再次进入/执行()方法，因为 在同一个类加载器下，一个类型只会被初始化一次。

静态内部类的特点：外部类加载时不需要加载静态内部类，不被加载则不占用内存（延迟加载）。当外部类调用getInstance方法时，才加载静态内部类，静态属性保证了全局唯一，静态变量初始化保证了线程安全，所以这里的方法没有加synchronized关键字（JVM保证了一个类的 初始化在多线程下被同步加锁）

3、反射破坏单例

public class LazyInnerClassSingletonTest {

    public static void main(String[] args) {
        try{
           
            Class<?> clazz = LazyInnerClassSingleton.class;
            //通过反射拿到私有的构造方法
            Constructor c = clazz.getDeclaredConstructor(null);
            //强制访问
            c.setAccessible(true);
            //暴力初始化
            Object o1 = c.newInstance();
            //调用了两次构造方法，相当于new了两次
            Object o2 = c.newInstance();

            System.out.println(o1 == o2);   //false
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

显然，是创建了两个不同的实例。现在，我们在其构造方法中做一些限制，一旦出现多次重复创建，则直接抛出异常。来看下优化后的构造方法，其他代码不变:

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

4、序列化破坏单例

当我们将一个单例对象创建好，有时候需要将对象序列化然后写入到磁盘，下次使用时再从磁盘中读取到对象，反序列化转化为内存对象。反序列化后的对象会重新分配内存，即重新创建。那如果序列化的目标的对象为单例对象，就违背了单例模式的初衷，相当于破坏了单例，来看一段代码：

//反序列化时导致单例破坏
public class SeriableSingleton implements Serializable {

    //序列化就是说把内存中的状态通过转换成字节码的形式
    //从而转换一个IO流，写入到其他地方(可以是磁盘、网络IO)
    //内存中状态给永久保存下来了

    //反序列化
    //讲已经持久化的字节码内容，转换为IO流
    //通过IO流的读取，进而将读取的内容转换为Java对象
    //在转换过程中会重新创建对象new

    public  final static SeriableSingleton INSTANCE = new SeriableSingleton();
    private SeriableSingleton(){}

    public static SeriableSingleton getInstance(){
        return INSTANCE;
    }
}

编写测试代码:

public class SeriableSingletonTest {
    public static void main(String[] args) {

        SeriableSingleton s1 = null;
        SeriableSingleton s2 = SeriableSingleton.getInstance();

        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("SeriableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();


            FileInputStream fis = new FileInputStream("SeriableSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            s1 = (SeriableSingleton)ois.readObject();
            ois.close();

            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s1 == s2);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果中，可以看出，反序列化后的对象和手动创建的对象是不一致的，实例化了两次，违背了单例的设计初衷。那么，我们如何保证序列化的情况下也能够实现单例？其实很简单，只需要增加readResolve()方法即可。

private  Object readResolve(){
        return  INSTANCE;
    }

至于为什么，希望读者朋友们自己去探索一下ObjectInputStream类的readObject()方法的源码，这里就不再做解释了。

还是解释一句吧:实际上在序列化和反序列化的过程中，对象是被创建了两次。这发生在JVM的层面，是安全的。重写readResolve，只是覆盖了反序列化出来的对象罢了。反序列化的对象也会被GC回收。

5、注册式单例

枚举【推荐】：

注册式单例又称为登记式单例，就是将每一个实例都登记到某一个地方，使用唯一的标识获取实例。注册式单例有两种写法：一种为容器缓存，一种为枚举登记。先来看枚举式单例的写法，来看代码，创建EnumSingleton类：

//常量中去使用，常量不就是用来大家都能够共用吗。
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 class EnumSingletonTest {

    public static void main(String[] args) {
        testSeriable();
    }

    /**
     * 测试序列化破坏单例
     */
    public static void testSeriable() {
        try {
            EnumSingleton instance1 = null;

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

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

            FileInputStream fis = new FileInputStream("EnumSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            instance1 = (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();
        }
        
    }


    /**
     * 测试反射破坏单例
     */
    public static void testReflect(){
        try {
            Class clazz = EnumSingleton.class;
            Constructor c = clazz.getDeclaredConstructor(String.class, int.class);
            c.setAccessible(true);
            EnumSingleton enumSingleton = (EnumSingleton) c.newInstance("Tom", 666);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

通过测试发现，序列化和反射都无法破坏单例。比较推荐此种写法。

通过源码分析，可以看到:

序列化无法破坏单例的原因:枚举类型其实通过类名和Class对象类找到一个唯一的枚举对象。因此，枚举对象不可能被类加载器加载多次。

容器缓存:

//Spring中的做法，就是用这种注册式单例
public class ContainerSingleton {
    private ContainerSingleton(){}
    private static Map<String,Object> ioc = new ConcurrentHashMap<String,Object>();
    public static Object getInstance(String className){
        synchronized (ioc) {
            if (!ioc.containsKey(className)) {
                Object obj = null;
                try {
                    obj = Class.forName(className).newInstance();
                    ioc.put(className, obj);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return obj;
            } else {
                return ioc.get(className);
            }
        }
    }
}