深入剖析单例模式的实现方式与线程安全问题：饿汉式 vs 懒汉式

一碗黄焖鸡三碗米饭

已于 2025-02-28 09:58:04 修改

阅读量755

点赞数 21

分类专栏： Java设计模式深度解析文章标签：单例模式 java 设计模式

于 2025-02-11 13:59:30 首次发布

本文链接：https://blog.youkuaiyun.com/sjdgehi/article/details/145570342

版权

Java设计模式深度解析专栏收录该内容

24 篇文章

订阅专栏

深入剖析单例模式的实现方式与线程安全问题：饿汉式 vs 懒汉式

单例模式（Singleton Pattern）是设计模式中的一种，旨在确保某个类在整个系统中只会存在一个实例，并提供全局访问点。单例模式常见的应用场景包括：数据库连接池、线程池、日志管理等系统组件，它们的存在需要确保在整个应用程序中只有一个实例来处理相关操作。尽管单例模式看似简单，但它的实现方式和线程安全问题却常常困扰开发者，尤其在多线程环境下。

本文将深入探讨单例模式的实现方式，重点介绍饿汉式单例和懒汉式单例的区别及它们的线程安全问题，帮助开发者更好地理解和使用单例模式。

1. 什么是单例模式？

单例模式是一种创建型设计模式，要求一个类在整个系统中只有一个实例，并且提供一个全局访问点。它的核心思想是确保类只有一个实例，并且提供一个访问该实例的方式。

实现单例模式的方式有很多种，主要的目标是保证类的实例在系统运行过程中只会被创建一次，而且全局都能共享这个实例。

2. 单例模式的实现方式

2.1 饿汉式单例（Eager Initialization）

饿汉式单例的实现是将类的实例在类加载时就创建好。因为类加载是线程安全的，所以这种方式天然地保证了线程安全问题。换句话说，饿汉式单例在类加载时就会初始化实例，确保在任何情况下都能获取到唯一的实例。

实现代码示例：

public class Singleton {
    // 在类加载时就创建单例对象
    private static final Singleton instance = new Singleton();

    // 私有化构造器，防止外部实例化
    private Singleton() {}

    // 提供公共的静态方法来访问实例
    public static Singleton getInstance() {
        return instance;
    }
}

饿汉式单例的特点：

线程安全：由于实例在类加载时就被创建，因此它是线程安全的，不需要额外的同步措施。
简单易懂：这种方式实现简单，代码清晰，易于理解。
缺点：饿汉式单例的缺点是无论是否使用这个实例，类的实例都会在程序启动时创建，这在某些情况下可能会导致资源浪费，尤其是在类的实例创建较为复杂或消耗大量资源时。

2.2 懒汉式单例（Lazy Initialization）

懒汉式单例的实现方式是实例在第一次使用时才会被创建。懒汉式单例的优点是只有在需要的时候才会创建实例，可以避免不必要的资源浪费。然而，懒汉式单例需要处理线程安全问题，因为多线程环境下可能会导致多个线程同时创建实例，从而破坏单例的唯一性。

实现代码示例：

public class Singleton {
    private static Singleton instance;

    // 私有化构造器，防止外部实例化
    private Singleton() {}

    // 提供公共的静态方法来获取实例，第一次访问时创建实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

懒汉式单例的特点：

资源延迟加载：实例只会在第一次被使用时才会被创建，因此避免了不必要的内存浪费。
需要考虑线程安全问题：懒汉式单例需要特别注意在多线程环境下，多个线程同时调用 getInstance() 方法时，可能会创建多个实例，从而破坏单例模式的设计。

3. 饿汉式与懒汉式单例的线程安全问题

3.1 饿汉式单例的线程安全问题

由于饿汉式单例是在类加载时就初始化实例，类加载本身是线程安全的，因此饿汉式单例天然地保证了线程安全。无论多少线程同时访问 getInstance() 方法，都不会导致多个实例的创建，因此不需要额外的同步处理。

饿汉式的优点：

线程安全：类的加载时机是由JVM保证的，所以不需要额外的同步机制。
性能较好：由于实例在类加载时就已创建，避免了后续的同步开销。

饿汉式的缺点：

可能浪费内存：即使某些实例在整个应用生命周期中从未使用，类加载时也会创建它，这在资源有限或类加载较为复杂的情况下可能导致浪费。

3.2 懒汉式单例的线程安全问题

懒汉式单例需要特别小心多线程环境下的并发问题。假设多个线程同时调用 getInstance() 方法，当 instance == null 时，会导致多个线程同时进入 if 判断并创建多个实例。这破坏了单例模式的核心目标。

线程安全问题的解决方案：

使用 synchronized 关键字

可以通过在 getInstance() 方法上添加 synchronized 关键字来解决线程安全问题。这样，在实例未创建时，只有一个线程能够执行实例创建的过程，其他线程会被阻塞。
```
public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
```
这种方式虽然能解决线程安全问题，但每次获取实例时都需要进行同步操作，导致性能开销较大。
双重检查锁定（Double-Checked Locking）

为了提高性能，可以使用双重检查锁定（DCL）来优化 synchronized 关键字的使用。第一次检查 instance 是否为空时，不加锁，直接返回；如果为空，再加锁并第二次检查实例是否为空。
```
public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
```
这种方式能有效避免每次调用时都进行同步，从而提高性能。但需要注意的是，instance 变量需要声明为 volatile，以确保线程间的可见性。
使用 Bill Pugh 单例模式（静态内部类）

另一种非常优雅且线程安全的方式是使用静态内部类来实现懒汉式单例。这种方式利用了类加载的线程安全特性，同时避免了同步开销。
```
public class Singleton {
    private Singleton() {}

    private static class SingletonHelper {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
}
```
这种方式的优势在于：
- 只有在调用 getInstance() 时，SingletonHelper 类才会被加载，实例才会被创建。
- 类加载机制天然保证了线程安全，不需要显式的同步。
- 相较于其他懒汉式方法，它更简洁高效。