实现单例模式的常见方式

找不到、了2025-06-06 10:54

前言

java有多种设计模式，如下图所示：

单例模式它确保一个类只有一个实例，并提供一个全局访问点。

1、单例模式介绍

1.1、使用原因

为什么要使用单例模式？

1. 控制资源访问

  • 核心价值：确保对共享资源（如配置文件、线程池、数据库连接池等）的单一访问点

  • 避免问题：防止多个实例同时操作同一资源导致的冲突或资源浪费

2. 保证数据一致性

  • 全局状态管理：当需要维护全局唯一状态时（如计数器、缓存等）

  • 避免不一致：多个实例可能导致数据不一致问题

3. 提高性能

  • 减少开销：避免频繁创建和销毁对象的开销

  • 资源共享：对于重量级对象（如数据库连接池），复用单一实例可显著提高性能

4. 简化设计

  • 明确职责：明确指定某些对象在系统中应该且只能有一个实例

  • 简化调用：通过全局访问点简化对象获取方式

1.2、使用场景

1. 配置类

代码示例：

java 复制代码 
public class AppConfig {
    private static AppConfig instance;
    private Properties configs;
    
    private AppConfig() {
        // 加载配置文件
        configs = loadConfigurations();
    }
    
    public static synchronized AppConfig getInstance() {
        if(instance == null) {
            instance = new AppConfig();
        }
        return instance;
    }
    
    public String getConfig(String key) {
        return configs.getProperty(key);
    }
}

适用原因：配置文件通常只需要加载一次，所有组件共享同一配置

2. 数据库连接池

java 复制代码 
public class ConnectionPool {
    private static ConnectionPool instance;
    private List<Connection> pool;
    
    private ConnectionPool() {
        // 初始化连接池
        initializePool();
    }
    
    public static ConnectionPool getInstance() {
        if(instance == null) {
            synchronized(ConnectionPool.class) {
                if(instance == null) {
                    instance = new ConnectionPool();
                }
            }
        }
        return instance;
    }
    
    public Connection getConnection() {
        // 从池中获取连接
    }
}

适用原因：连接池应全局唯一，避免多次创建导致资源耗尽。

3. 缓存系统

java 复制代码 
public class CacheManager {
    private static CacheManager instance;
    private Map<String, Object> cache;
    
    private CacheManager() {
        cache = new ConcurrentHashMap<>();
    }
    
    public static CacheManager getInstance() {
        if(instance == null) {
            synchronized(CacheManager.class) {
                if(instance == null) {
                    instance = new CacheManager();
                }
            }
        }
        return instance;
    }
    
    public void put(String key, Object value) {
        cache.put(key, value);
    }
    
    public Object get(String key) {
        return cache.get(key);
    }
}

适用原因：缓存需要全局统一，避免多实例导致缓存不一致

1.3、现代替代方案

在依赖注入框架（如Spring）中，通常使用容器管理的单例（通过@Singleton或@Component注解）而非手动实现单例模式，这样更灵活且易于测试。

2、实现方式

2.1、饿汉式

代码示例如下：

java 复制代码 
public class Singleton {

    private static final Singleton instance = new Singleton();
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        return instance;
    }
}

特点 ：类加载时就初始化实例，由JVM保证线程安全
优点 ：实现简单，线程安全
缺点：可能造成资源浪费（如果实例未被使用）

2.2、懒汉式

java 复制代码 
public class Singleton {
    private static Singleton instance;
    
    private Singleton() {}
    
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

特点 ：使用synchronized关键字保证线程安全
优点 ：延迟加载
缺点：每次获取实例都需要同步，性能较差

2.3、双重检查锁定

工作流程如下：

bash 复制代码 
线程A调用getInstance()
       │
       ├─ 第一次检查(instance == null?) → 如果非null，直接返回
       │
       ↓ 如果null
进入同步块
       │
       ├─ 第二次检查(instance == null?) → 如果非null，说明其他线程已创建
       │
       ↓ 如果null
创建新实例
       │
       ↓
退出同步块
返回实例

代码示例如下：

java 复制代码 
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;
    }
}

特点：

  • 第一次检查避免不必要的同步

  • 第二次检查确保只有一个实例被创建

  • volatile关键字防止指令重排序

首次为null检查的原因：

  • 第一次检查在同步块外部进行

  • 如果实例已经创建(不为null)，直接返回实例，完全跳过同步块

  • 这消除了**99%**的情况下的同步开销（因为大多数时候实例已经存在）

优点 ：线程安全且性能较好
缺点：实现稍复杂

2.4、静态内部类

java 复制代码 
public class Singleton {
    private Singleton() {}
    
    private static class Holder {
        static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

特点 ：利用类加载机制保证线程安全
优点 ：延迟加载，线程安全，实现简单
缺点：无法防止反射攻击

2.5、枚举

java 复制代码 
public enum Singleton {
    INSTANCE;
    
    public void doSomething() {
        // 方法实现
    }
}

特点：

  • 由JVM保证线程安全

  • 防止反射攻击

  • 自动支持序列化机制

优点 ：实现简单，线程安全，防止多实例
缺点：不够灵活（不能延迟加载）

从字节码层面看，枚举会被编译为：

java 复制代码 
public final class Singleton extends Enum<Singleton> {
    public static final Singleton INSTANCE;
    
    static {
        INSTANCE = new Singleton("INSTANCE", 0);
        // 其他静态初始化
    }
    
    // 私有构造器
    private Singleton(String name, int ordinal) {
        super(name, ordinal);
    }
    
    // 其他方法...
}

JVM会保证：

  1. 枚举的构造器是私有的

  2. 枚举的实例化在静态初始化块中完成，且只执行一次

  3. 任何通过反射调用枚举构造器的操作都会抛出IllegalArgumentException

3、实际应用

3.1. Spring的Bean管理

场景：Spring容器默认管理的Bean都是单例的

java 复制代码 
@Service
public class PaymentService {
    // Spring管理的单例
    public void processPayment(Order order) {
        // 支付处理逻辑
    }
}

// 使用时自动注入单例
@Controller
public class OrderController {
    @Autowired
    private PaymentService paymentService; // 注入的是单例实例
    
    public void placeOrder(Order order) {
        paymentService.processPayment(order);
    }
}

特点：

  • 通过@Service/@Component注解声明单例

  • 由Spring容器保证单例性

  • 整个应用共享同一个实例

3.2. 日志记录器

场景：应用中所有日志记录使用同一个日志管理器

java 复制代码 
// 实际日志框架使用单例模式
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class UserService {
    // 每个类获取自己的Logger，但底层LoggerFactory是单例管理的
    private static final Logger logger = LoggerFactory.getLogger(UserService.class);
    
    public void createUser(User user) {
        logger.info("Creating user: {}", user.getUsername());
        // 用户创建逻辑
    }
}

实现原理：

  • 日志框架内部维护单例的LoggerContext

  • 避免每个类都创建新的日志管理器实例

3.3. 数据库连接池

场景：应用中使用单一连接池管理所有数据库连接

java 复制代码 
// 配置Hikari连接池（单例）
public class DatabasePool {
    private static HikariDataSource dataSource;
    
    static {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        config.setUsername("user");
        config.setPassword("password");
        dataSource = new HikariDataSource(config);
    }
    
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
}

// 使用示例
public class UserDao {
    public User getUserById(int id) {
        try (Connection conn = DatabasePool.getConnection()) {
            // 查询用户逻辑
        }
    }
}

优势：

  • 避免每次请求都新建连接

  • 统一管理连接资源

3.4. 配置管理中心

场景：全局共享配置信息

java 复制代码 
public class AppConfig {
    private static AppConfig instance;
    private Properties properties;
    
    private AppConfig() {
        loadConfig();
    }
    
    public static AppConfig getInstance() {
        if (instance == null) {
            synchronized (AppConfig.class) {
                if (instance == null) {
                    instance = new AppConfig();
                }
            }
        }
        return instance;
    }
    
    private void loadConfig() {
        properties = new Properties();
        try (InputStream is = getClass().getResourceAsStream("/app.properties")) {
            properties.load(is);
        }
    }
    
    public String getConfig(String key) {
        return properties.getProperty(key);
    }
}

// 使用示例
public class PaymentService {
    private String apiKey = AppConfig.getInstance().getConfig("payment.api.key");
    
    public void processPayment() {
        // 使用配置的apiKey
    }
}

3.5. 缓存管理器

场景：应用级缓存需要全局唯一

java 复制代码 
public class CacheManager {
    private static volatile CacheManager instance;
    private ConcurrentMap<String, Object> cache;
    
    private CacheManager() {
        cache = new ConcurrentHashMap<>();
    }
    
    public static CacheManager getInstance() {
        if (instance == null) {
            synchronized (CacheManager.class) {
                if (instance == null) {
                    instance = new CacheManager();
                }
            }
        }
        return instance;
    }
    
    public void put(String key, Object value) {
        cache.put(key, value);
    }
    
    public Object get(String key) {
        return cache.get(key);
    }
}

// 使用示例
public class ProductService {
    public Product getProduct(String id) {
        Product product = (Product) CacheManager.getInstance().get(id);
        if (product == null) {
            product = loadFromDatabase(id);
            CacheManager.getInstance().put(id, product);
        }
        return product;
    }
}

单例模式在基础设施组件（日志、配置、连接池等）中使用最为广泛，但在业务代码中应谨慎使用，以避免造成不必要的耦合。

总结

在Java中，枚举是实现单例模式的最佳实践，除非你需要延迟加载（枚举是类加载时就初始化），否则应该优先考虑使用枚举方式实现单例。

相关推荐
_r0bin_16 分钟前
前端面试准备-7
开发语言·前端·javascript·fetch·跨域·class
zhang988000017 分钟前
JavaScript 核心原理深度解析-不停留于表面的VUE等的使用！
开发语言·javascript·vue.js
硅的褶皱1 小时前
对比分析LinkedBlockingQueue和SynchronousQueue
java·并发编程
MoFe11 小时前
【.net core】天地图坐标转换为高德地图坐标（WGS84 坐标转 GCJ02 坐标）
java·前端·.netcore
季鸢2 小时前
Java设计模式之观察者模式详解
java·观察者模式·设计模式
Fanxt_Ja2 小时前
【JVM】三色标记法原理
java·开发语言·jvm·算法
蓝婷儿2 小时前
6个月Python学习计划 Day 15 - 函数式编程、高阶函数、生成器/迭代器
开发语言·python·学习
love530love2 小时前
【笔记】在 MSYS2（MINGW64）中正确安装 Rust
运维·开发语言·人工智能·windows·笔记·python·rust
Mr Aokey3 小时前
Spring MVC参数绑定终极手册：单&多参/对象/集合/JSON/文件上传精讲
java·后端·spring
slandarer3 小时前
MATLAB | 绘图复刻（十九）| 轻松拿捏 Nature Communications 绘图
开发语言·matlab
热门推荐
01基于STM32的智能电池管理系统02KGG转MP3工具|非KGM文件|解密音频03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑05DeepSeek各版本说明与优缺点分析06【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！07VMware虚拟机安装Win7专业版保姆级教程（附镜像包）08wandb使用遇到的一些问题09组基轨迹建模 GBTM的介绍与实现（Stata 或 R）10Coze扣子平台完整体验和实践（附国内和国际版对比）