设计模式----单例模式

一、简介

        单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例。单例模式分为饿汉式和懒汉式两种，分别在类加载时创建和使用时创建。

二、详解

        1、饿汉式

                饿汉式单例在类加载时就创建了实例，在代码中的实现如下：

public class Demo1 {

    // 创建私有构造方法（防止外界直接new）
    private Demo1(){

    }
    // 创建对象
    private static Demo1 demo1 = new Demo1();

    // 提供公共的访问方式，让外界获取该对象
    public static Demo1 getDemo1(){
        return demo1;
    }

}

        2、懒汉式

                懒汉式单例在首次使用时创建，需要考虑多线程情况下的问题。

public class Demo2 {

    // 私有的构造方法
    private Demo2(){

    }
    // 声明变量
    private static Demo2 demo2;

    /**
     * 在多线程情况下会造成线程不安全
     * @return
     */
    public static Demo2 getDemo2(){
        
        // 判断对象是否为空
        if (demo2 == null) {
            demo2 = new Demo2();
        }
        return demo2;
    }
}

                分析造成线程不安全的原因：多个线程同时调用getDemo2方法时，可能同时判断demo2 == null 为true，造成不同线程创建了不同的实例。最简单的解决方法就是在getDemo2方法上加上synchronized关键字，如下：

public static synchronized Demo2 getDemo2(){

        // 判断对象是否为空
        if (demo2 == null) {
            demo2 = new Demo2();
        }
        return demo2;
}

                上述方案可以解决线程安全问题，但是效率会降低，可以使用双重检查方式：

public static synchronized Demo2 getDemo2(){
        
        if (demo2 == null){ // 第一次判断
            // 注意：此处可能有多个线程因为获取不到锁阻塞到这。
            synchronized (Demo2.class){
                if (demo2 == null) { // 第二次判断
                    demo2 = new Demo2();
                }
            }
        }
        return demo2;
}

        注意：由于在多线程情况下的指令重排序可能会造成空指针异常，所以要在变量上加上volatile关键字。

// 声明变量
private volatile static Demo2 demo2;

        3、饿汉式-静态内部类方式

                普通的实现方式需要用到锁，会影响性能。可以使用静态内部类的方式实现饿汉式单例：

public class Demo3 {

    // 私有构造方法
    private Demo3(){}

    // 静态内部类(只有在首次调用时才被加载)
    private static class Singleton {
        private static final Demo3 INSTANCE = new Demo3();
    }

    // 外界调用的方法
    public static Demo3 getInstance(){
        return Singleton.INSTANCE;
    }
}

         小结：静态内部类单例模式是一种优秀的单例模式，是开源项目中常用的一种单例模式。在没有加锁的情况下保证了线程的的安全，并且没有任何性能影响和空间浪费。

三、破坏单例

        1、序列化破坏单例

                使用io序列化类，反序列化时会创建不同的对象，解决方案：类中加入readResolve()。

// 反序列化时被调用的方法（解决序列化破坏单例）
    public Object readResolve(){
        return Singleton.INSTANCE;
   }

        2、反射破坏单例

                使用反射获取字节码对象、获取构造方法、使用构造方法创建对象，可以创造出不同的对象。解决方法：在私有构造方法中加判断：

private static boolean flag = false;

    // 私有构造方法(解决反射破坏单例)
    private Demo3(){
        synchronized (Demo3.class) {
            if (flag) {
                throw new RuntimeException("单例对象不能重复创建对象");
            }
            flag = true;
        }
    }