设计模式——单例模式

介绍

单例模式（Singleton），保证一个类仅有一个实例，并提供一个访问它的全局访问点。

通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。

 Singleton类，定义一个GetInstance操作，允许客户访问它的唯一实例。GetInstance是一个静态方法，主要负责创建自己的唯一实例。

Spring中的单例模式，提供了全局访问点BeanFactory，但没有从构造器级别去控制单例（Spring管理的是任意的Java对象）。

单例模式，属于创建型模式。它保证从系统启动到系统终止，全过程只会产生一个实例。当我们在应用中遇到功能性冲突的时候，需要使用单例模式。

应用场景

配置文件、日历、IOC容器

常用写法

常用单例模式写法为：饿汉式、懒汉式、注册式、序列化

饿汉模式

• 在类加载的时候就立即初始化，并且创建单例对象。
• 优点：没有加任何的锁，执行效率比较高。
• 缺点：类加载的时候就初始化，不管用还是不用，都占着空间，浪费内存。
• 线程安全性：在线程还没出现以前就实例化了，是线程安全的。

public class Singleton {
    private static final Singleton instance = new Singleton();
    
    private Singleton() {}
    
    public static Singleton GetInstance() {
        return instance;
    }
}

懒汉模式

• 在外部需要使用的时候才进行初始化
• 常见有三种写法，下面会详细介绍

lazy1

public class LazyOne {
    private LazyOne() {}

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

    public static LazyOne getInstance() {
        // 调用方法之前，先判断
        // 如果没有初始化，将其进行初始化，并且赋值
        // 将该实例缓存好
        if(lazy == null) {
            // 两个线程都会进入这个if里面,不是线程安全的。
            lazy = new LazyOne();
        }
        // 如果已经初始化，直接返回之前已经保存好的结果
        return lazy;
    }
}

lazy2

public class LazyTwo {
    private LazyTwo() {}

    // 静态快，公共内存区域
    private static LazyTwo lazy = null;
    // synchronized 保证了线程安全，但是性能损耗大
    public static synchronized LazyTwo getInstance() {
        if(lazy == null) {
            lazy = new LazyTwo();
        }
        return lazy;
    }
}

lazy3

在外部类被调用的时候，内部类才会被加载；内部类一定是要在方法调用之前初始化，巧妙的避免了线程安全问题；巧妙的避免了线程安全问题；这种形式兼顾了饿汉式的内存浪费，也兼顾了synchronized性能问题，完美的屏蔽了这两个缺点。

public class LazyThree {
    private boolean initialized = false;

    // 默认使用LazyThree的时候，会先初始化内部类
    // 如果没使用的话，内部类是不加载的
    private LazyThree() {
        synchronized (LazyThree.class) {
            if(initialized == false) {
                initialized = !initialized;
            } else {
                throw new RuntimeException("单例已被侵犯");
            }
        }
    }

    // static是为了使单例的空间共享
    // 保证这个方法不会被重写，重载
    public static final LazyThree getInstance() {
        return LazyHolder.LAZY;
    }

    private static class LazyHolder{
        private static final LazyThree LAZY = new LazyThree();
    }
}

但是lazy3在反射初始化时，不是线程安全的。

try {
            // 很无聊的情况下，进行破坏
            Class<?> clazz = LazyThree.class;
            // 通过反射拿到私有的构造方法
            Constructor c = clazz.getDeclaredConstructor(null);
            c.setAccessible(true);
            // 暴力初始化
            Object o1 = c.newInstance();
            // 调用了两次构造方法，相当于new了两次
            // 犯了原则性问题
            Object o2 = c.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();
        }

序列化

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

反序列化时会导致单例被破坏。

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

注册模式

Spring中用的就是这种注册式单例。

public class BeanFactory {
    private BeanFactory() {}
    // 线程安全
    private static Map<String,Object> ioc = new ConcurrentHashMap();

    public static Object getBean(String className) {
        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);
        }
    }
}

总结

一般情况下，建议使用第三种懒汉模式。即能解决线程安全问题，还能兼顾到性能。但Spring由于要创建多个bean，它采用的是注册模式。