单例模式和工厂模式

1、单例模式

1.1、什么是单例模式？

单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。

1.2、单例模式的类型

单例模式有两种类型：
1、懒汉式：在真正需要使用对象时才去创建该单例类对象；
2、饿汉式：在类加载时已经创建好该单例对象，等待被程序使用。

1.3、懒汉式

懒汉式创建对象的方法是在程序使用对象前，先判断该对象是否已经实例化（判空），若已实例化直接返回该类对象，否则则先执行实例化操作。

public class Signal {
    private static Signal signal;
    private Signal(){};
    public static Signal getInstance(){
        if(signal==null){
            signal=new Signal();
        }
        return signal;
    }
}

1.3.1、解决多线程懒汉式问题

如果两个线程同时判断singleton为空，那么它们都会去实例化一个Singleton对象，这就变成双例了。所以，我们要解决的是线程安全问题。

最容易想到的解决方法就是对类的对象加锁，程序就会变成下面这个样子：

public class Signal {
    private static Signal signal;
    private Signal(){};
    public static  Signal getInstance(){
        synchronized(Signal.class){
            if(signal==null){
                signal=new Signal();
            }
        }
        return signal;
    }
}

这样就规避了两个线程同时创建Signal对象的风险，但是引来另外一个问题：每次去获取对象都需要先获取锁，并发性能非常地差，极端情况下，可能会出现卡顿现象。

接下来要做的就是优化性能，目标是：如果没有实例化对象则加锁创建，如果已经实例化了，则不需要加锁，直接获取实例。

public class Signal {
    private static Signal signal;
    private Signal(){};
    public static  Signal getInstance(){
        // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
        if(signal==null){
            // 线程A或线程B获得该锁进行初始化
            synchronized (Signal.class){
                // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                if(signal==null){
                    signal=new Signal();
                }
            }
        }
        return signal;
    }
}

上面的代码已经完美地解决了并发安全+性能低效问题：

• 如果signal不为空，则直接返回对象，不需要获取锁；而如果多个线程发现singleton为空，则进入分支；
• 多个线程尝试争抢同一个锁，只有一个线程争抢成功，第一个获取到锁的线程会再次判断signal是否为空，因为signal有可能已经被之前的线程实例化；
• 其它之后获取到锁的线程在执行到第4行校验代码，发现signal已经不为空了，则不会再new一个对象，直接返回对象即可;
• 之后所有进入该方法的线程都不会去获取锁，在第一次判断signal对象时已经不为空了；

因为需要两次判空，且对类对象加锁，该懒汉式写法也被称为：Double Check（双重校验） + Lock（加锁）。

上述代码还存在最后一个问题，就是指令重排序。

创建一个对象，在JVM中会经过三步：
1、为signal分配内存空间；
2、初始化signal对象；
3、将signal指向分配好的内存空间。

指令重排序是指：JVM在保证最终结果正确的情况下，可以不按照程序编码的顺序执行语句，尽可能提高程序的性能。

在这三步中，第2、3步有可能会发生指令重排现象，创建对象的顺序变为1-3-2，会导致多个线程获取对象时，有可能线程A创建对象的过程中，执行了1、3步骤，线程B判断singleton已经不为空，获取到未初始化的singleton对象，就会报NPE异常。文字较为晦涩，可以看流程图：

使用volatile关键字可以防止指令重排序，所以最终的懒汉式单例模式为：

public class Signal {
    private static volatile Signal signal;
    private Signal(){};
    public static  Signal getInstance(){
        // 线程A和线程B同时看到singleton = null，如果不为null，则直接返回singleton
        if(signal==null){
            // 线程A或线程B获得该锁进行初始化
            synchronized (Signal.class){
                // 其中一个线程进入该分支，另外一个线程则不会进入该分支
                if(signal==null){
                    signal=new Signal();
                }
            }
        }
        return signal;
    }
}

1.4、饿汉式

饿汉式在类加载时已经创建好该对象，在程序调用时直接返回该单例对象即可，即我们在编码时就已经指明了要马上创建这个对象，不需要等到被调用时再去创建。

public class Signal {
    private static final Signal signal=new Signal();
    private Signal(){};
    public static  Signal getInstance(){
        return signal;
    }
}

上述的代码，在第二步已经实例化好了一个Sinal对象在内存中，不会有多个Sinal对象实例存在；
类在加载时会在堆内存中创建一个Sinal对象，当类被卸载时，Sinal对象也随之消亡了。

1.5、破坏懒汉式单例与饿汉式单例

无论是完美的懒汉式还是饿汉式，终究敌不过反射和序列化，它们俩都可以把单例对象破坏掉（产生多个对象）。

1.5.1、反射破坏单例模式

public static void main(String[] args) {
    // 获取类的显式构造器
    Constructor<Singleton> construct = Singleton.class.getDeclaredConstructor();
    // 可访问私有构造器
    construct.setAccessible(true); 
    // 利用反射构造新对象
    Singleton obj1 = construct.newInstance(); 
}

1.5.2、序列化与反序列化破坏单例模式

public static void main(String[] args) {
    // 创建输出流
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Singleton.file"));
    // 将单例对象写到文件中
    oos.writeObject(Singleton.getInstance());
    // 从文件中读取单例对象
    File file = new File("Singleton.file");
    ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
    Singleton newInstance = (Singleton) ois.readObject();
}