详细分析单例模式

目录

1.单例模式的定义

2.单例模式的实现方式

1.饿汉模式

2.懒汉模式

（1）线程不安全的问题怎么解决？

（2）直接对整个getInstance方法代码块加锁吗？

（3）那对if语句加锁不就行了吗？

（4）那在if语句内部加锁可以吗？

（5）应用双重if语句判断

（6）加入volatile防止指令重排序

3.相关的面试题

（1）为什么需要双重检查？

（2）为什么需要加volatile修饰？

（3）为什么静态内部类不需要加volatile修饰？

（4）单例模式的缺点是什么？

---

1.单例模式的定义

单例模式是一种创建型设计模式,确保一个类只有一个实例，并提供全局访问点。单例模式常用于管理共享资源（如数据库连接池、线程池、配置对象等）。

其中的设计模式指的是解决软件设计中常见问题的可复用方案，是面向对象编程的经验总结。它们分为 创建型、结构型 和 行为型 三大类。简要说就是类似于框架，是大佬们提供的可供使用的一种“公式”。

2.单例模式的实现方式

1.饿汉模式

public class Singleton {private static final Singleton INSTANCE = new Singleton(); // 类加载时创建private Singleton() {} // 私有构造方法public static Singleton getInstance() {return INSTANCE;}
}

饿汉模式指的是在方法加载的同时就初始化实例（不管你用不用，我先开头就把实例创建了）。

优点：简单，线程安全（JVM保证类加载时的线程安全）。

缺点：即便不使用也会照常创建方法，可能会造成资源浪费。

2.懒汉模式

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

懒汉模式指的是方法加载时不先创建实例，等到真正用到的时候再创建。

优点：资源利用率高，避免不必要的实例创建。

缺点：带来了线程不安全的问题。

（1）线程不安全的问题怎么解决？

由于懒汉模式带来的线程不安全问题，我们要在代码中加入锁，也就是加入synchronized关键字。

（2）直接对整个getInstance方法代码块加锁吗？

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

像这样直接对整个getInstance方法修饰synchronized关键字固然可以解决线程安全问题。

但是由于整个getInstance方法只有在第一次创建实例时会进入if语句，存在线程安全隐患；其他情况下，代码会略过if语句，直接return，也就不存在线程安全问题了。

直接对整个方法加锁会导致不必要的开销变大 （加锁的开销），资源利用率降低。

（3）那对if语句加锁不就行了吗？

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

这样写的代码,虽然没有对整个方法加锁,但是在代码执行过程中,不管有没有创建完成实例,都会对if语句加锁,然后再判断if语句。

这依然会导致性能低下。

（4）那在if语句内部加锁可以吗？

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

这样虽然解决了开销问题，但是在进入if语句之后，加锁之前，如果线程被调度走（抢走），其他线程创建了实例，代码继续执行，这时，锁才刚被加上。

这就会导致多次创建实例。

（5）应用双重if语句判断

public class Singleton {private static volatile Singleton instance; // ✅ volatile 禁止指令重排序private Singleton() {}public static Singleton getInstance() {if (instance == null) {               // 第一次检查（无锁）synchronized (Singleton.class) {   // 加锁if (instance == null) {       // 第二次检查（有锁）instance = new Singleton();}}}return instance;}
}

第一次if语句判断是否是第一次创建实例，减少全部加锁的不必要开销。

第二次if语句判断加锁完成后其他线程是否创建了实例，防止多次创建实例。

（6）加入volatile防止指令重排序

指令重排序是编译器和处理器为了优化程序性能，在不改变程序语义（单线程环境下最终执行结果）的前提下，对指令的执行顺序进行重新排列的一种优化手段。不过在多线程环境中，指令重排序可能会引发一些难以调试的问题。

因为实例的创建不是原子的，instance = new Singleton()分为三步：1.分配内存空间，2.初始化对象，3.将instance指向内存地址。

所以如果触发编译器的指令重排序，就有可能打乱instance = new Singleton()的三步的顺序，造成线程不安全。

public class Singleton {private static volatile Singleton instance; // ⚠️ 必须加 volatileprivate Singleton() {}public static Singleton getInstance() {if (instance == null) { // 第一次检查（无锁）synchronized (Singleton.class) { // 加锁if (instance == null) { // 第二次检查（有锁）instance = new Singleton();}}}return instance;}
}

3.相关的面试题

（1）为什么需要双重检查？

第一重if检查是否是第一次创建实例，这样可以保证在以后得代码执行过程中直接跳过if语句代码块，减少不必要的开销（加锁）。

第二重if检查进入第一重if语句之后，加锁之前，线程是否有被调度走，实例是否已经被创建完毕。

避免多次创建实例。

（2）为什么需要加volatile修饰？

防止指令重排序。

创建实例的过程不是原子的，instance = new Singleton()分为三步：

（1）分配内存空间

（2）初始化对象

（3）istance指向内存空间

指令重排序可能会打乱这三步，导致其他线程拿到未创建的实例或者多次创建实例。

（3）为什么静态内部类不需要加volatile修饰？

public class Singleton {private Singleton() {}private static class SingletonHolder {private static final Singleton INSTANCE = new Singleton(); // 类加载时创建}public static Singleton getInstance() {return SingletonHolder.INSTANCE; // 第一次调用时加载内部类}
}

因为JVM保证了线程安全，并且初始化是原子的。

（4）单例模式的缺点是什么？

（1）难以拓展，通常不允许子类化。

（2）隐藏了依赖关系

（3）长期持有对象可能增加内存压力。