当前位置：首页 > news >正文

详细分析单例模式

news 2025/7/7 22:48:05

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; // ⚠️ 必须加 volatile
    
    private 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保证了线程安全，并且初始化是原子的。