【七】一文带你迅速掌握设计模式中的单例模式

1. 什么是设计模式

设计模式可以理解为就是一种固定套路，就好比你和对手下棋得时候，会有一些固定套路下法；而设计模式就是软件开发的棋谱~
设计模式有很多种，接下来就介绍一种校招阶段，主要考察的两种设计模式:

• 单例模式
• 工厂模式

2. 单例模式

所谓的单例模式就是单个实例（对象），进一步的解释就是在一个程序中，某个类，只能创建出一个实例（一个对象），不能创建多个实例（多个对象）
在Java中的单例模式，借助Java语法，保证某个类，只能够创建出一个实例，而不能new多次~~
那为什么要有这个单例模式式呢？是因为在有些场景中，本身就要求某个概念是单例的~

Java中实现单例模式有很多种写法，接下来主要介绍两种

• 饿汉模式
• 懒汉模式

可以举一个计算机中的例子来解释下什么是饿汉模式，什么是懒汉模式
假设我们打开一个硬盘上的文件，读取文件内容，并显示出来
饿汉模式：把文件所有内容都读到内存中，并显示
懒汉模式：只把文件读一小部分，把当前屏幕填充上，如果用户翻页了，再读其他文件内容，如果不翻页，就省下了~
这种情况下，如果文件非常大，饿汉模式就可能打开卡半天，但是懒汉模式可以快速打开~

2.1 饿汉模式（急迫）

class Singleton{
    // 唯一实例的本体
    private static Singleton instance = new Singleton();

    // 获取到实例的方法
    public static Singleton getInstance() {
        return instance;
    }

    // 禁止外部 new 实例
    private Singleton(){

    }
}
public class Demo13 {
    public static void main(String[] args) {
        // 此时 s1 和 s2 是同一个对象
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        
        // Singleton s3 = new Singleton();  此处不允许 new
    }
}

上述代码就是饿汉模式！但是有个缺点，就是在类加载的时候，就完成了实例的创建，那如果后面没有用到这个实例呢？ 接下来我们介绍另外一个懒汉模式~

2.2 懒汉模式（从容）

class SingletonLazy {
    private static SingletonLazy instance = null;

    public static SingletonLazy getInstance() {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }

    private SingletonLazy() {
    }
}
public class Demo14 {
    public static void main(String[] args) {
        SingletonLazy s1 = SingletonLazy.getInstance();
        SingletonLazy s2 = SingletonLazy.getInstance();
        System.out.println(s1 == s2);
    }
}

上述代码，就是懒汉模式，在调用的时候，才会真正去创建实例~

2.3 多线程下不安全

我们对比下 饿汉模式 和 懒汉模式分析下哪一个在多线程下是安全的？

通过对比可以，分析出 懒汉模式在多线程情况下是会不安全的！下面进行详细分析，在多线程下，懒汉模式可能无法保证创建对象的唯一性~

2.3.1 饿汉模式（多线程版）

class SingletonLazy {
    private static SingletonLazy instance = null;

    public static SingletonLazy getInstance() {
        synchronized (SingletonLazy.class){
            if (instance == null) {
                instance = new SingletonLazy();
            }
        }
        return instance;
    }

    private SingletonLazy() {
    }
}

public class Demo14 {
    public static void main(String[] args) {
        SingletonLazy s1 = SingletonLazy.getInstance();
        SingletonLazy s2 = SingletonLazy.getInstance();
        System.out.println(s1 == s2);
    }
}

只有确保 判定 和 new 操作是原子性的操作才能保证多线程操作下的安全！ 但是其实加锁是一个比较低效的操作！（加锁就可能涉及到阻塞等待），所以一般的非必要不要加锁~

2.3.2 饿汉模式（多线程改进版）

由于上述代码中，只要调用getInstance就会触发锁竞争！~其实我们只要一分析一开始懒汉模式的代码，就会发现，此处的线程不安全操作，只出现了首次创建实例的处，一旦实例创建好以后，后续调用getInstance，只是读操作！，所以可以将代码进行优化

class SingletonLazy {
    private static SingletonLazy instance = null;

    public static SingletonLazy getInstance() {
        // 这个条件，判断是否要加锁，如果对象已经有了，就不必加锁了，此时
        if (instance == null) {
            synchronized (SingletonLazy.class) {
            	// 这个条件是判断对象是否为空
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
            return instance;
        }
    private SingletonLazy() {}
    }

    public class Demo14 {
        public static void main(String[] args) {
            SingletonLazy s1 = SingletonLazy.getInstance();
            SingletonLazy s2 = SingletonLazy.getInstance();
            System.out.println(s1 == s2);
        }
    }

只要在外层，再次加一个判定条件，这样就可以减少不必要的锁竞争。

2.3.2 饿汉模式 （多线程最终版）

尽管上述代码，已经进行了优化，但是仍旧存在一个问题，指令重排序问题！

所以就需要加 volatile 关键字保证指令重排序问题

class SingletonLazy {
    volatile private static SingletonLazy instance = null;

    public static SingletonLazy getInstance() {
        // 这个条件，判断是否要加锁，如果对象已经有了，就不必加锁了，
        if (instance == null) {
            synchronized (SingletonLazy.class) {
                if (instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
            return instance;
        }
    private SingletonLazy() {}
    }

    public class Demo14 {
        public static void main(String[] args) {
            SingletonLazy s1 = SingletonLazy.getInstance();
            SingletonLazy s2 = SingletonLazy.getInstance();
            System.out.println(s1 == s2);
        }
    }

2.4 总结

• 饿汉模式：天然线程安全，只是读操作
• 懒汉模式：不安全的，有读也有写
  • 加锁，把 if 和 new 变成原子操作
  • 双重 if，减少不必要的加锁操作
  • 使用 volatile 禁止指令重排序，保证后续线程肯定能拿到的是完整对象