7.多线程之单例模式

单例模式

文章目录

单例模式
[1. 什么是单例模式](#1. 什么是单例模式)
[2. 饿汉模式](#2. 饿汉模式)
[3. 懒汉模式](#3. 懒汉模式)
- [3.1 单线程版：](#3.1 单线程版：)
- [3.2 多线程版](#3.2 多线程版)

1. 什么是单例模式

单例模式是一种设计模式，常见的设计模式还有工厂模式、建造者模式等。

设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。我们使用这些设计模式，相当于是前辈们 在一些特殊的场景 下总结出的经验，我们直接使用即可，相当于站在巨人的肩膀上编程！！！

单例模式是针对一些特定的类，只允许创建一个实例 。为什么会有单例模式？因为引入单例模式后，在代码层面会有强制检查，不会允许创建出第二个实例，避免一些bug，人为检查是及其不可靠、不可控的。

单例模式有两种实现方式，分别是饿汉模式和懒汉模式，我们就这两种实现展开。

2. 饿汉模式

Java 复制代码

class Singleton{
    private static Singleton instance = new Singleton();
    public static Singleton getInstance() {
        return instance;
    }
    private Singleton() {}
}
public class Test {
    public static void main(String[] args) {
        Singleton sgt1 = Singleton.getInstance();
        Singleton sgt2 = Singleton.getInstance();
        System.out.println(sgt1 == sgt2);
    }
}

运行结果~~

Java 复制代码

true

进程已结束，退出代码为 0

饿汉模式首先是线程安全的，对象在类加载时就会创建好，然后将构造方法设为私有，不允许再创建实例，最后通过公有方法将这个对象提供给外层调用。

这种模式为什么叫饿汉模式呢？其实也很简单，无论外层需不需要使用这个对象，在类加载时这个对象就已经创建了。而相比于饿汉模式，懒汉模式的做法则更加高效，在第一次实用类的时候，在进行创建。

3. 懒汉模式

3.1 单线程版：

Java 复制代码

class Singleton {
    private static Singleton instance = null;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
       }
        return instance;
   }
}

为什么说这样实现懒汉模式是单线程版本？因为这个版本的懒汉模式在并发环境下，会产生线程安全问题，即线程不安全。

线程安全问题发生在首次创建实例时. 如果在多个线程中同时调getInstance 方法, 就可能导致创建出多个实例。一旦实例已经创建好了, 后面再多线程环境调用 getInstance 就不再有线程安全问题了(不再修改instance 了)，因此枷锁（synchronized）可以一定程度上改善这个问题。

这个版本的懒汉模式，在多线程环境下，一但有其他线程在第一次创建对象时穿插（OS系统调度）进行执行，就可能会创建出多个实例。

3.2 多线程版

Java 复制代码

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

在这个版本中对if判断进行枷锁，保证了创建对象时不会有其它线程穿插执行，在进一步给instance使用volatile修饰（保证可见性、顺序），从而保证了线程安全。我们进一步发现，只有在第一次进入时，才会需要创建对象，而如果每次都枷锁，就会降低程序的执行效率，所以我么在外部又嵌套了一层if。此处要注意的是这两层if虽然条件一样，但是含义却不一样。

锁竞争（枷锁解锁）的开销是比较大的，而懒汉模式只有在第一次才需要创建对象（产生锁竞争），后续就不在需要锁竞争了，也不必枷锁。

外层if ：外层if是判断单例模式的对象是否创建出来，如果已经创建，则直接返回instance（instance被volatile修饰，不会产生内存可见性问题），不会产生锁竞争。
内层if：当线程第一次执行时会进入内层，竞争同一把锁，假设线程1拿到锁，就可以创建出对象，此时线程1执行完后，由于没内存可见性问题，其它线程就会发现instance已经不为空了，从而不会继续进入外层if竞争锁对象，降低了锁竞争的开销。

如果本篇文章对你有帮助，请点赞、评论、转发，你的支持是我创作的动力！！！