线程并发下的单例模式

文章目录

- - **什么是单例模式？**
  - **多线程环境下单例模式的挑战**
  - **线程并发下单例模式的实现方式**
  - - [**1. 饿汉式单例（线程安全）**](#1. 饿汉式单例（线程安全）)
    - [**2. 懒汉式单例（线程不安全）**](#2. 懒汉式单例（线程不安全）)
    - [**3. 懒汉式单例（线程安全，使用同步）**](#3. 懒汉式单例（线程安全，使用同步）)
    - [**4. 双重检查锁定（Double-Checked Locking，推荐）**](#4. 双重检查锁定（Double-Checked Locking，推荐）)
    - [**5. 静态内部类（推荐）**](#5. 静态内部类（推荐）)
    - [**6. 枚举单例（最佳实践之一）**](#6. 枚举单例（最佳实践之一）)
  - **单例模式的对比总结**
  - **单例模式的适用场景**
  - **总结**

在多线程环境下实现单例模式是一个经典的编程问题，因为线程并发可能会破坏单例模式的正确性。如果处理不当，可能导致多线程同时创建多个实例，进而违背单例模式的设计初衷。

以下将详细讲解单例模式在多线程并发环境下的实现，以及如何保证线程安全。

什么是单例模式？

单例模式（Singleton Pattern）是一种创建型设计模式，其目的是确保某个类在整个程序运行期间只有一个实例，并且提供一个全局访问点来获取该实例。

单例模式通常有以下特点：

类只能有一个实例。
提供一个全局访问点，用于获取该实例。
对象的生命周期由类自身管理。

多线程环境下单例模式的挑战

在单线程环境中，实现单例模式相对简单，不需要担心线程竞争问题。然而，在多线程环境下，如果多个线程同时访问单例的创建逻辑，可能会导致以下问题：

创建多个实例：多个线程可能同时判断实例未被创建，然后各自创建一个实例。
数据不一致：并发线程可能导致单例的状态不确定。

为了解决这些问题，我们需要在单例模式中引入线程同步机制，以确保线程安全。

线程并发下单例模式的实现方式

以下是一些常见的实现单例模式的线程安全方法。

1. 饿汉式单例（线程安全）

饿汉式单例在类加载时就创建实例，天然是线程安全的，因为类加载过程是由 JVM 控制的，线程是串行化的。

java 复制代码

public class Singleton {
    // 静态实例，类加载时就初始化
    private static final Singleton INSTANCE = new Singleton();

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

    // 提供全局访问点
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

优点：

实现简单。
在类加载时就完成实例化，避免了多线程问题。

缺点：

即使实例从未被使用，也会被创建，可能浪费内存。

2. 懒汉式单例（线程不安全）

懒汉式单例延迟加载实例，只有在第一次调用时才会创建实例。但这种方式在多线程环境下是不安全的。

java 复制代码

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) { // 非线程安全
            instance = new Singleton();
        }
        return instance;
    }
}

问题：

如果多个线程同时判断 instance == null 为真，可能会创建多个实例。

3. 懒汉式单例（线程安全，使用同步）

使用 synchronized 关键字可以确保线程安全：

java 复制代码

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

优点：

简单实现线程安全。

缺点：

使用 synchronized 会导致性能下降，因为每次访问都需要加锁。

4. 双重检查锁定（Double-Checked Locking，推荐）

双重检查锁定优化了性能，只有在第一次创建实例时才会加锁，后续访问不会加锁。

java 复制代码

public class Singleton {
    // 使用 volatile 确保可见性和禁止指令重排序
    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;
    }
}

优点：

只有在第一次创建实例时才加锁，性能较高。
线程安全。

注意：volatile 关键字用于防止指令重排序，确保对象在初始化完成之前不会被其他线程看到。

5. 静态内部类（推荐）

静态内部类结合了懒加载和线程安全的优点，是单例模式的推荐实现方式。静态内部类在被使用时才会加载，由 JVM 保证线程安全。

java 复制代码

public class Singleton {
    private Singleton() {}

    // 静态内部类
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

优点：

实现简单且高效。
线程安全。
具有延迟加载（Lazy Initialization）的特性。

6. 枚举单例（最佳实践之一）

枚举单例利用枚举类型的特性，天然支持线程安全，且防止反序列化破坏单例。

java 复制代码

public enum Singleton {
    INSTANCE;

    public void someMethod() {
        // 实例方法
    }
}

优点：

写法简单。
线程安全。
防止反序列化和反射漏洞。

缺点：

可能不符合传统单例的语义（如需要懒加载）。

单例模式的对比总结

实现方式	线程安全	延迟加载	实现难度	性能	备注
饿汉式单例	是	否	简单	高	不使用时可能浪费资源
懒汉式单例（非线程安全）	否	是	简单	高	不适用于多线程环境
懒汉式单例（线程安全）	是	是	简单	低	加锁影响性能
双重检查锁定	是	是	较复杂	高	推荐，在高并发中表现优异
静态内部类	是	是	简单	高	推荐，优雅且性能高
枚举单例	是	否	简单	高	防止反射和序列化破坏

单例模式的适用场景

配置管理类：如全局配置文件的读取。
连接池：数据库连接池或线程池的管理。
日志系统：全局的日志记录类。
应用程序上下文 ：如 Spring 的 ApplicationContext。
缓存：全局共享的缓存对象。

总结

在多线程环境下，推荐使用 双重检查锁定 或 静态内部类 实现单例模式，因为它们能够很好地兼顾线程安全和性能。同时，枚举单例 是一种更为优雅和安全的实现方式，特别是在需要防止反序列化和反射攻击时。