设计模式之单列模式

单列模式是一种经典的设计模式，在校招中最乐意考的设计模式之一~

设计模式就是软件开发中的棋谱，大佬们针对一些常见的场景，总结出来的代码的编写套路，按照套路来写，不说你写的多好，至少不会太差~

在校招中，主要考察两个设计模式：单列模式，工厂模式

本文主要讲解单列模式

单列《——》单列模式（instance)对象

一个程序中，某个类只创建出一个实列（对象）——》不能创建多个对象！

Java中的单列模式借助Java语法，保证某个类只能创建出一个实列，而不能new多次！！有些场景，本身就是要求某个概念是单列的！！

在Java语法中，如何做出单列模式的实现呢？？

Java中实现单列模式的有很多种写法：起码有5/6种写法，但是课堂上主要说两种：

• 饿汉模式（饥饿）
• 懒汉模式（从容）

饿汉：吃完饭就立刻去洗碗

懒汉：吃完饭之后，先把碗放到一边，等到下一顿吃的时候，需要用到碗了再洗，通常认为懒汉模式更好（效率更高）

比如：中午吃饭，用了4个碗

饿汉：吃完就得把4个碗都洗了

懒汉：晚上吃饭只用2个碗，此时只需要洗2个就ok了

计算机中的列子，打开一个硬盘上的文件，读取文件内容，并显示出来：

饿汉：把文件所有的内存都读到内存中，并显示出来

懒汉：只把文件读一小部分，把当前屏幕填充上，如果用户翻页了，在读其他文件内容，如果不翻页就省下了

假设文件非常大：10G：

饿汉模式：文件可能卡半天！内存够不够？？

懒汉模式：可以快速打开！

我们来看一下下述代码吧：饿汉模式：

class Singleton{
    //唯一的实体
    private static Singleton instance=new Singleton();
    
    //获取到实列的方法
    public static Singleton getInstance(){
        return instance;//单词的读操作，不涉及修改
    }
 
    //禁止外部new实列
    //此处，在类内部把实列创建好，同时禁止外部重新创建实列，此时就可以保证是单列的特性了！
    private Singleton(){
        //构造方法设为private
        //仅类内部使用
    }
}
 
 
public class Main {
    public static void main(String[] args) {
        //此时s1和s2是同一个对象
        Singleton s1=Singleton.getInstance();
        Singleton s2=Singleton.getInstance();
        
        //Singleton s3=new Singleton();
        //此处要把new操作禁止掉，则把该类的构造方法设为private即可
    }
}

上述代码是线程安全的（饿汉模式），先创建好实列，随去随用~

private static Singleton instance=new Singleton();

在上述的该段代码中：被static修饰，该属性是类的熟悉，JVM中，每个类的类对象只有唯一一份，类对象里的这个成员，自然也是唯一的！！

但是对于创建的这个实列，我们可以用不到，因此：非必要不创建《——》懒汉模式

懒汉模式的核心思想：——》非必要不创建

//通过懒汉模式实现一下单列模式
class SingletonLazy{
    volatile private static SingletonLazy instance=null;//先置为空
 
    //只有调用getInstance才会new一个对象，如果再次调用getInstance，仍然会返回之前的实列
    public static SingletonLazy getInstance(){
        //这个条件，判定是否需要加锁，如果对象已经有了，
        //就不必加锁了，此时本身就是线程安全的
        if (instance==null){
            synchronized (SingletonLazy.class){
                //加锁，保证判定和new是一个原子操作
                if (instance==null){
                    instance=new SingletonLazy();
                }
            }
        }
        return instance;//唯一
    }
 
    private SingletonLazy(){
        //构造方法设为private
        //类中可以访问，类外不能访问
    }
}
 
 
public class Main1 {
    public static void main(String[] args) {
        SingletonLazy s1=SingletonLazy.getInstance();
        SingletonLazy s2=SingletonLazy.getInstance();
        //此时s1和s2是同一个实列
        System.out.println(s1==s2);//true
    }
}

显而易见，上述代码的运行结果为：

思考一下：对于前面的饿汉模式和懒汉模式的两个代码，是否线程安全？？

对于饿汉模式：认为线程安全的——》只是读数据

对于懒汉模式：多线程下调用getInstance，可能会出现问题《——》线程不安全

多线程下，懒汉模式可能无法保证创建对象的唯一性！！

懒汉模式的部分代码如下：

如果是N个线程一起调用，可能就会搞出N个对象了！！

通过加锁操作《——》锁要加在哪里？？多线程的代码是很复杂的，不是说只要写了加锁操作，就一定是线程安全了，只能具体问题具体分析。

加锁，是一个比较低效的操作（加锁就可能涉及到阻塞等待~）！！非必要不加锁

对于getInstance()这个方法：

在该段代码中，任何时候调用getInstance()，都会触发锁的竞争。

其实，此处的线程不安全，只出现在首次创建对象这里，一旦对象new好了，后续在调用getInstance()，就只是单纯的读操作了，就没有线程安全问题，就没有必要再加锁了！！

因此，可以在加一个if语句的判定（两个if语句的判定更加完美）

这两个if (instance==null)的代码，看起来一样，实际上，他俩的差别很大！！按照咱们之前的理解，两行代码如果紧挨着的，此时两行代码就会被迅速的执行完，近似就可以看作是“同一时机”，实际上，由于这两个if中间间隔了个synchronized，加锁可能导致阻塞，至于啥时候解除阻塞，时间不一定！！虽然两个条件相同，但是如果调用时间长了，结果也可能会不同~！！

加上volatile可以解决指令重排序的问题：

volatile private static SingletonLazy instance=null;//先置为空

小结一下，瞬间开心：

单列模式的线程安全问题：（经典面试题）

饿汉模式：天然就是安全的，只是读操作

懒汉模式：不安全，有读也有写操作

• 加锁，把if和new变成原子操作
• 双重if，减少不必要的加锁操作
• 使用volatile，禁止指令重排序，保证后续线程拿到的是完整对象