设计模式之单例模式（面试高频）（创建型）

单例模式概念及应用场景

概念：
顾名思义单例模式即一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。
应用场景

• J2EE中的ServletContext，ServletContextConfig等
• Spring框架中的ApplicationContext
• 数据库中的连接池

饿汉式单例

在类加载的时候就立即初始化，创建单例对象。它绝对线程安全，在线程还没出现以前就实例化了，不存在访问安全问题

坏处
如果系统有大量的单例对象，那么系统初始化的时候就会把所有的单例对象都直接初始化（不管用不用都得初始化），这会导致内存浪费，所以它适用于单例对象较少的情况

代码

饿汉式写法一

public class HungrySingleton {

    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    private HungrySingleton(){}

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

饿汉式写法二

public class HungryStaticSingleton {
    //类的加载顺序
    //先静态后动态
    //先上，后下
    //先属性后方法
    private static final HungryStaticSingleton hungrySingleton;

    static {
        hungrySingleton = new HungryStaticSingleton();
    }

    private HungryStaticSingleton(){}

    public static HungryStaticSingleton getInstance(){
        return  hungrySingleton;
    }
}

懒汉式单例

懒即等到需要用到这个单例对象的时候才new，解决饿汉式的问题

错误代码

public class LazySimpleSingletion {
    private static LazySimpleSingletion instance;
    private LazySimpleSingletion(){}
    //这个方法有问题，没有考虑线程安全问题
     public  static LazySimpleSingletion getInstance(){
    if(instance == null){
        instance = new LazySimpleSingletion();
    }
    return instance;
   }

}

这个代码没有考虑线程安全问题，打印分为两种情况

• 若打印的对象是一样的也不一定代表只new了一个对象，有两种情况：
  1.正常顺序执行，即线程0和线程1没有同时在条件内部
  2.后者覆盖前者的情况，这个就new了两个对象，相当于线程0执行instance = new LazySimpleSingletion()前，线程1也进入了这个条件内部，然后线程0返回值之前，线程1又new完了，导致instance指向了线程1new的对象，线程0返回的值也理所应当为线程1new的对象。所以打印结果一样，但是new了两个对象，线程0new的那个对象已经没有指针指向了！

• 若打印的对象是不一样的，则说明，线程0和线程1都同时存在于条件内部，线程0new完后且返回instance值后，线程1才new

建议大家自己debug一下，印象会更深刻，多线程debug的方法在下面

简单懒汉式

//加上synchronized关键字就可以了
public synchronized static LazySimpleSingletion getInstance(){
        if(instance == null){
            instance = new LazySimpleSingletion();
        }
        return instance;
    }

这个时候再去debug就发现真正的解决了

线程0在方法体内的时候，线程1根本进不去，且状态变为monitor状态

线程0执行完后，线程1就恢复为running状态了

加上synchronized后解决了线程安全问题，但又造成了新的问题（性能下降）：即这个方法只能有一个线程进去，而当new完后，若大量线程需要去拿到这个instance的地址则会排队，但此时其实已经完全不需要排队了，可以一起放他们进来了，因为这个时候的大量线程肯定都无法new对象了

双重检查法

instance为空的时候才阻塞，否则说明已经创建成功，不用阻塞，直接返回

public class LazyDoubleCheckSingleton {
    private volatile static LazyDoubleCheckSingleton instance;
    private LazyDoubleCheckSingleton(){}
public static LazyDoubleCheckSingleton getInstance(){
        //检查是否要阻塞
        if (instance == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                //检查是否已经创建好了实例
                if (instance == null) {
                    instance = new LazyDoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

注意：synchronized里面必须再次检查instance是否为空，否则这种情况依旧会导致线程不安全：线程0和线程1同时进入第一个条件内部，线程0先进synchronized里面去new对象然后返回，如果里面不再检查一次，线程1进去了还是会继续new对象
指令重排序的问题导致volatile关键字也是必需要的，参考文章1参考文章2

反射破坏

前4种写法都可以被反射破坏，因为它们的构造方法里面都没有进行防反射的操作，
new对象时（不管正常new还是反射new)都必须调用空构造器（如果不使用带有参数的的构造器）

public class ReflectTest {
    public static void main(String[] args) {
        try {
            Class<?> clazz = LazyDoubleCheckSingleton.class;
           // Class<?> clazz = LazyStaticInnerClassSingleton.class;
           
            //拿到构造器
            Constructor c = clazz.getDeclaredConstructor(null);
            //修改private权限
            c.setAccessible(true);

            Object instance1 = c.newInstance();

            Object instance2 = c.newInstance();

            System.out.println(instance1);

            System.out.println(instance2);

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

解决反射破坏问题可以靠下面这个写法

静态内部类写法

public class LazyStaticInnerClassSingleton {

    private LazyStaticInnerClassSingleton(){
    //防止被反射破坏
        if(LazyHolder.INSTANCE != null){
            throw new RuntimeException("不允许非法访问");
        }
    }

    private static LazyStaticInnerClassSingleton getInstance(){
        return LazyHolder.INSTANCE;
    }

    //静态内部类在你需要用的时候才分配内存
    private static class LazyHolder{
        private static final LazyStaticInnerClassSingleton INSTANCE = new LazyStaticInnerClassSingleton();
    }

}

说明：JVM一来只加载LazyStaticInnerClassSingleton类，调用getInstance方法时，才加载LazyHolder

优点：写法优雅（利用了Java本身语法特点），性能高（未使用synchronized关键字），避免了内存浪费（懒汉式）,不能被反射破坏（构造器进行了处理，其它方法不能像这样处理）

多线程debug方法

断点处标记debug后，右键点击选择Thread模式。

主线程跑起后，在这个框框里面去切换线程跑，然后按f7就可以往下一步执行了。

注册式单例

枚举式单例写法

《Effective java》推荐的最优雅的单例模式写法是枚举式单例

待更

容器式单例（Spring改良的）

解决枚举饿汉式的问题

public class ContainerSingleton {

    private ContainerSingleton(){}

    private static Map<String,Object> ioc = new ConcurrentHashMap<String, Object>();

    public static Object getInstance(String className){
        Object instance = null;
        if(!ioc.containsKey(className)){
            //双重检查
            synchronized (ContainerSingleton.class) {
                if(!ioc.containsKey(className)) {
                    try {
                        instance = Class.forName(className).newInstance();
                        ioc.put(className, instance);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return instance;
                }
                else{
                    return ioc.get(className);
                }
            }
        }else{
            return ioc.get(className);
        }
    }

}

序列化破坏单例

序列化的过程

• 把内存中对象的状态转换为字节码的形式
• 把字节码通过IO输出流，写到磁盘上
• 永久保存下来，持久化

反序列化的过程

• 将持久化的字节码内容，通过IO输入流读到内存中来
• 转化成一个Java对象

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方法）

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

    public static SeriableSingleton getInstance(){
        return INSTANCE;
    }

    private Object readResolve(){ return INSTANCE;}
 }

原因

待更

ThreadLocal单例（不常用）

不能保证其创建的单例是全局唯一的，但是能保证在单个线程中是唯一的，它天生是线程安全的

待更

单例模式在源码中的应用

• spring框架中的AbstractFactoryBean地getObject方法

public final T getObject() throws Exception {
        if (this.isSingleton()) {
            return this.initialized ? this.singletonInstance : this.getEarlySingletonInstance();
        } else {
            return this.createInstance();
        }
    }