单例模式

2021-06-09 本文已影响0人云芈山人

单例模式是创建型模式的一种，他提供了创建对象的最佳模式。此模式涉及到一个单一的类，该类负责创建自己的实例，并确保只有单个对象被创建。此类提供了访问其唯一对象的方式，可以直接访问，可以不用实例化该类的对象。
注意：
1. 单例类只有一个实例；
2. 单例类必须自己创建自己的实例类；
3. 单例类必须给所有其他对象开放（即提供该实例类）。

如何保证一个类在内存中只能有一个实例呢？
1. 构造私有;
2. 使用私有静态成员变量初始化本身对象;
3. 对外提供静态公共方法获取本身对象。

介绍

有何目的：保证一个类只有一个实例，并提供一个访问他的全局访问点。
解决什么：一个全局使用的类频繁的创建与销毁。
如何解决：判断系统是否有这个实例，有则返回，无则创建。
何时使用：想控制创建实例数目，节省系统资源。
关键代码：私有的构造函数。
实际应用：例如要求生成唯一序列号，网站访问人数等。
优点：减少内存开销及资源的占用。
缺点：没有接口，不能继承，与单一职责原则冲突（一个类应只关心内部逻辑，不管外部如何实例化）。

实现

提供了两种实现模式：饿汉式与懒汉式（延迟加载）。

一、饿汉式实现

例如：

public class Student {

    // 2：成员变量初始化本身对象
    //static修饰的变量在new对象时，不存在多线程问题
    private static Student student = new Student();

    // 构造私有
    private Student() {}

    // 3：对外提供公共方法获取对象
    public static Student getSingletonInstance() {
        return student;
    }

    public void sayHello(String name) {
        System.out.println("hello," + name);
    }
}

饿汉式单例模式是线程安全的。

static修饰的变量在new对象时，不存在多线程问题。JVM通过类加载器去加载一个类的时候，默认针对该流程是加锁的，也就是线程安全的。类加载的时候，会初始化类的静态成员，其实就是调用clinit()方法。

如何判断存在线程安全问题？

是否存在共享数据（存储数据的成员变量）；
是否存在多线程；
是否是非原子性操作。

二、懒汉式实现（延迟加载）

疑问：饿汉式既然是线程安全的，为什么还要用懒汉式实现方式？

如果存在很多对象，需要单例模式去管理。而有的对象不需要创建，如果都使用饿汉式去创建，就会造成资源的浪费。

懒汉式有三种方式：

双重检查锁方式
静态内部类方式
枚举方式

懒汉式实现的思想：需要对象的时候，再去创建对象。

懒汉式实现的步骤：

构造私有；
定义私有静态成员变量，但先不初始化；
定义公开静态方法，获取本身对象（有对象就返回已有对象，没有对象，再去创建）。

2.1 静态内部类方式：

public class Student {

    private Student() {}

    /*
     * 此处使用一个内部类来维护单例 JVM在类加载的时候，是互斥的，所以可以由此保证线程安全问题
     */
    private static class SingletonFactory {
        private static Student student = new Student();
    }

    /* 获取实例 */
    public static Student getSingletonInstance() {
        return SingletonFactory.student;
    }

}

2.2 双重检查锁方式演变

public class Student {

    //1：构造私有
    private Student(){}
    
    //2：定义私有静态成员变量，先不初始化
    private static Student student = null;
    
    //3：定义公开静态方法，获取本身对象
    public static Student getSingletonInstance(){
        //没有对象，再去创建
        if (student == null) {
            student = new Student();
        }
        //有对象就返回已有对象
        return student;
    }
    
}

这种方式基本满足懒汉式基本要求，但却存在线程安全的问题。如何解决线程安全的问题 ?

首先想到对getSingletonInstance方法加synchronized关键字。

如下：

public class Student {

    private Student(){}
    
    private static Student student = null;
    
    // 此处考验对synchronized知识点的掌握情况
    public static synchronized Student getSingletonInstance(){
        if (student == null) {
            student = new Student();
        }
        return student;
    }
    
}

synchronized关键字作用

确保线程互斥地访问同步代码
保证共享变量的修改能够及时可见
有效解决重排序问题

synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降。因为每次调用getSingletonInstance()方法，都要对对象上锁。事实上，只有在第一次创建对象的时候加锁，之后就不需要了。所以需要在此基础上做出优化。

将synchronized关键字加在方法体内部
如下：

public class Student {

    private static Student student = null;
    private Student() {}
    public static Student getSingletonInstance() {
        if (student == null) {
            // 采用这种方式，对于对象的选择会有问题
            // JVM优化机制：先分配内存空间，再初始化
            synchronized (Student.class) {
                if (student == null) {
                    student = new Student();
                    //student.setName("ss")
                    //new ---- 开辟JVM中堆空间---产生堆内存地址保存到栈内存的student引用中---创建对象
                    // 存在的问题：指令重排
                }
            }
        }
        return student;
    }
    //student.getName();
}

这样做似乎解决了之前性能的问题，将synchronized关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升。

但是如果发生以下情况，就会出现问题。

在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();语句是分两步执行的。

JVM中的对象创建过程是什么流程？

Student student = new Student();// 高级语言
a）new关键字会触发Student类的类加载（如果已加载，则此步骤作废）
b）根据Class对象中的信息，去开辟相应大小的内存空间
c）初始化Student对象，就是完成成员变量的初始化操作（到这一步，我们才能说该对象是可用的）
d）将开辟出来的内存空间地址，赋值给栈空间的变量student

以上步骤，其实都是通过字节码指令去完成的（物理机器直接操作的都是CPU指令（原子性其实是相对我们CPU指令来说的））

指令重排序（JIT即时编译器优化）
有序性：代码执行时有序的。
如果两行代码交换不会影响最终的执行结果，那么JIT即时编译器就会根据情况去进行指令重排序。

可见如果程序之间没有依赖性，指令就可能发生重排（happend-before先行发生原则（六大原则））。
JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例（分析创建对象的步骤中，c和d这两个步骤，有没有依赖性呢？答案是它们两者之间没有依赖性，那么就有可能发生指令重排序。也就是说有可能先执行d再执行c）。
这样就可能出错了，我们以A、B两个线程为例：

a）A、B线程同时进入了第一个if判断；
b）A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();
c）由于JVM内部的优化机制(指令重排序)，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。
d）B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。
e）此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。

所以程序还是有可能发生错误，其实程序在运行过程是很复杂的，从这点我们就可以看出，尤其是在写多线程环境下的程序更有难度，有挑战性。我们对该程序做进一步优化。

双重检查加锁
如下：

public class Student{

    private volatile static Student student;

    private Student() {
    }

    public static Student getSingletonInstance() {
        if (student == null) {
            synchronized (Student.class) {
                if (student == null) {
                    student = new Student();
                }
            }
        }
        return student;
    }

}

volatile关键字的作用：

禁止指令重排序
禁止使用CPU缓存

可见性

在CPU单核时代，线程1和线程2使用的是同一个CPU缓存，所以线程之间的数据是可见的。
在CPU多核时代，线程1在A核，线程2在B核，每个核都有自己的CPU缓存空间，如果线程1产生的数据缓存没有同步到线程2对应的CPU缓存，则会出现可见性问题。

CPU、内存、磁盘的处理速度不同。为了提供CPU使用率，硬件提供了在内存与CPU之间的高速缓存，即CPU缓存。