【Java设计模式】校招最常考的单例模式

一、什么是单例模式？

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

这种模式的好处在于：

• 减少了系统的开销；
• 有些场景只需要一个实例，比如JDBC中的DataSource；
• 只有一个实例，节约了内存资源，提高了系统性能。

二、单例模式的类型

单例模式有两种类型：

• 饿汉式：在类加载时已经创建好该单例对象，等待被程序使用
• 懒汉式：在真正需要使用对象时才去创建该单例对象

2.1 饿汉模式

饿汉模式，顾名思义，饿汉很饿，所以它在类加载时就创建好了对象，在程序调用时直接返回该单例对象即可。下面看一下代码：

/**
 * 单例模式
 * 饿汉模式
 */
public class DataSourceSingleton {
    //1.提供私有的构造方法（防止外部直接new这个对象）
    private DataSourceSingleton(){

    }

    //2.创建一个私有的属性对象
    private static DataSourceSingleton dataSource=new DataSourceSingleton();

    //3.提供公共对外的单例对象
    public static DataSourceSingleton getInstance(){
        return dataSource;
    }
}

此处已经创建好了一个单例对象在内存中，不会有多个对象存在。

饿汉模式的特点：

• 在类加载时创建好该单例对象，在获取类单例对象时直接返回对象即可，不存在并发安全的问题和性能问题。

2.2 懒汉模式

懒汉模式在真正调用到这个对象时，才会去创建对象，在创建对象前判断该对象是否已经实例化，若已经实例化，直接返回该类对象，否则先执行初始化操作。

2.2.1 普通懒汉模式

先来看懒汉模式的基础代码:

/**
 * 单例模式
 * 懒汉模式
 */
public class DataSourceSingleton2 {
    //1.创建私有的构造方法
    private DataSourceSingleton2(){

    }
    //2.创建私有的属性对象
    private static DataSourceSingleton2 dataSource;

    //3.提供对外的单例对象
    public static DataSourceSingleton2 getInstance() throws InterruptedException {
        if(dataSource==null){//第一次访问
            Thread.sleep(500);
            dataSource=new DataSourceSingleton2();
        }
        return dataSource;
    }
}

看起来是没什么问题的，确实，在单线程模式下这种写法是没有问题的，但是如果是多线程呢？
假设现在有两个线程同时调用该对象，会出现什么的效果呢？

这时我们看到，就会有两个对象了，就变成双例了，所以我们要解决线程安全问题。
前面我们也讲过解决线程安全的方法，感兴趣的小伙伴可以去看解决线程安全问题
那我们就尝试给方法加锁，肯定可以解决线程安全的问题。

/**
 * 单例模式
 * 懒汉模式
 */
public class DataSourceSingleton2 {
    //1.创建私有的构造方法
    private DataSourceSingleton2(){

    }
    //2.创建私有的属性对象
    private static DataSourceSingleton2 dataSource;

    //3.提供对外的单例对象
    public synchronized static DataSourceSingleton2 getInstance() throws InterruptedException {
        if(dataSource==null){//第一次访问
            Thread.sleep(500);
            dataSource=new DataSourceSingleton2();
        }
        return dataSource;
    }
    
    //或者
    
     //3.提供对外的单例对象
    public static DataSourceSingleton2 getInstance() throws InterruptedException {
        synchronized (DataSourceSingleton2.class) {
            if (dataSource == null) {//第一次访问
                Thread.sleep(500);
                dataSource = new DataSourceSingleton2();
            }
        }
        return dataSource;
    }
}

但是这种方法的问题又在于，锁的粒度过于大了，每次调用这个对象都要先获取锁，性能非常差，所以我们现在要做的就是优化性能。

2.2.2 DCL版懒汉模式

因此我们想到了可以两次判空，且对类对象加锁，这种写法也叫做：Double Check +Lock（DCL）双重校验加锁。

/**
 * 懒汉模式版本 3 (最终线程安全版本)
 */
public class DataSourceSingleton3 {
    //1.私有的构造方法
    private DataSourceSingleton3(){

    }
    //2.创建私有的属性对象
    private static DataSourceSingleton3 dataSource;
    //3.创建公共方法，得到单例对象
    public static DataSourceSingleton3 getInstance(){
        if(dataSource==null) {//大致分流的状态
             synchronized (DataSourceSingleton3.class) {
                 if (dataSource == null) {//精细化的判断（分流）
                        dataSource = new DataSourceSingleton3();
                 }
             }
        }
        return dataSource;
    }
}

上面的代码就完美的i二觉了并发安全+性能低效的问题：

• ①中如果dataSource不为空，则直接返回对象，不需要获取锁；如果多个线程发现dataSoure为空，则进入分支；
• ②中多个线程争抢一个锁，只有一个线程争抢成功，第一个获取锁的线程会执行③再次判断datatSource是否为空，因为dataSource有可能已经被初始化过了；
• 后面再次获取锁的线程，在执行③的校验代码时，会发现dataSource已经不为空了，所以就不会去new一个对象，直接返回对象即可。

上面的代码看着已经很完美了，但其实还是存在一个问题，那就是指令重排序。

2.2.3 使用volatile防止指令重排序

new一个对象，在JVM中会经过三步：

1. 给dataSource分配内存空间
2. 初始化dataSource对象
3. 讲dataSource指向分配好的内存空间

JVM为了提高系统的性能，会在保证最终结果的正确的情况下，自发的修改代码的执行流程。

在这三步中，第2、3步有可能会发生指令重排序问题，创建对象的顺序变为1-3-2，会导致多个线程创建对象时，有可能线程A创建对象的过程中，执行了第1、3步，线程B 判断对象已经不为空，获取到未初始化的对象，直接返回了一个没有初始化的空的对象。

使用volatile可以防止指令重排序，也就是**使用volatile修饰的变量，可以保证其指令执行的顺序与程序指明的顺序一致，不会发生顺序变换。**可以看看之前的这篇博客，有讲volatile的其他作用。volatile的作用
懒汉模式的终极版代码如下所示：

/**
 * 懒汉模式版本 3 (最终线程安全版本)
 */
public class DataSourceSingleton3 {
    //1.私有的构造方法
    private DataSourceSingleton3(){

    }
    //2.创建私有的属性对象
    private volatile static DataSourceSingleton3 dataSource;
    //3.创建公共方法，得到单例对象
    public static DataSourceSingleton3 getInstance(){
        if(dataSource==null) {//大致分流的状态
             synchronized (DataSourceSingleton3.class) {
                 if (dataSource == null) {//精细化的判断（分流）
                        dataSource = new DataSourceSingleton3();
                 }
             }
        }
        return dataSource;
    }
}

三、枚举实现单例模式

使用枚举实现单例模式时，不需要做任何额外的操作就可以保证对象的单一性和线程安全性。
以下代码用来证明程序启动时仅会创建一个Singleton对象且是线程安全的。

简单理解：在程序启动时，会调用Singleton的空参构造器，实例化好一个Singleton对象赋给INSTANCE，之后再也不会实例化。

public enum Singleton {
    INSTANCE;
    Singleton(){
        System.out.println("枚举创建对象了");
    }

    public static void main(String[] args) {
        Singleton t1=Singleton.INSTANCE;
        Singleton t2=Singleton.INSTANCE;
        System.out.print(t1==t2);
    }
}

枚举实现单例模式的代码：

public enum SingletonEnum {
    INSTANCE;
    public SingletonEnum getInstance(){
        return INSTANCE;
    }
}

枚举是实现单例模式最好的方式，他的代码相比于懒汉模式和饿汉模式都更加简洁，并且没有线程安全问题，并且Enum内部防止反射和反序列化时破坏单例。

以上就是单例模式的介绍啦，觉得有帮助的小伙伴记得帮我点赞哦~~