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

实现单例模式的常见方式

news 2025/6/6 9:45:43

前言

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

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

1、单例模式介绍

1.1、使用原因

为什么要使用单例模式？

1. 控制资源访问

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

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

2. 保证数据一致性

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

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

3. 提高性能

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

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

4. 简化设计

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

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

1.2、使用场景

1. 配置类

代码示例：

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. 数据库连接池

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. 缓存系统

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、饿汉式

代码示例如下：

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

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

2.2、懒汉式

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、双重检查锁定

工作流程如下：

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

代码示例如下：

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、静态内部类

public class Singleton {private Singleton() {}private static class Holder {static final Singleton INSTANCE = new Singleton();}public static Singleton getInstance() {return Holder.INSTANCE;}
}

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

2.5、枚举

public enum Singleton {INSTANCE;public void doSomething() {// 方法实现}
}

特点：

  • 由JVM保证线程安全

  • 防止反射攻击

  • 自动支持序列化机制

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

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

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都是单例的

@Service
public class PaymentService {// Spring管理的单例public void processPayment(Order order) {// 支付处理逻辑}
}// 使用时自动注入单例
@Controller
public class OrderController {@Autowiredprivate PaymentService paymentService; // 注入的是单例实例public void placeOrder(Order order) {paymentService.processPayment(order);}
}

特点：

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

  • 由Spring容器保证单例性

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

3.2. 日志记录器

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

// 实际日志框架使用单例模式
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. 数据库连接池

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

// 配置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. 配置管理中心

场景：全局共享配置信息

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. 缓存管理器

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

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

http://www.xdnf.cn/news/891199.html

相关文章：

  • Redis Set集合命令、内部编码及应用场景(详细)
  • GC1809：高性能音频接收与转换芯片
  • Python Day42 学习（日志Day9复习）
  • AI智能推荐实战之RunnableParallel并行链
  • .Net Framework 4/C# System.IO 命名空间（文件的输入输出）
  • 深度学习之模型压缩三驾马车：基于ResNet18的模型剪枝实战（2）
  • 箭头函数和普通函数的this指向
  • BLE中心与外围设备MTU协商过程详解
  • 炫云：为驱动数字视觉产业升级保驾护航
  • 【设计模式-4.11】行为型——解释器模式
  • centos实现SSH远程登录
  • 分布式一致性原理及一致性协议
  • AI数字人小程序开发，重塑商业服务新模式
  • 6个月Python学习计划 Day 15 - 函数式编程、高阶函数、生成器/迭代器
  • 分析vban的utlis中的helper方法（1）——数组
  • 【技术笔记】AI Agent 项目 SUNA 部署：MSYS2 环境中 Python 版本从 3.12 降级至 3.11 的实操指南
  • place 布局管理器
  • java使用文本相似度检测可以调整阈值
  • Redis 配置与优化
  • LAUNCHXL-F28379D SCI中断配置
  • 什么是数据孤岛？如何实现从数据孤岛到数据共享？
  • java.io.IOException: Broken pipe
  • leetcode 1061. 按字典序排列最小的等效字符串 中等
  • js 比较两个对象的值是否相等
  • 【数据集】MODIS 8日合成1公里地表温度LST产品
  • Ubuntu20.04配置静态ip
  • 摄像头模块未来技术发展方向
  • 行业赋能篇-2-能源行业安全运维升级
  • MLP（多层感知机）
  • 算法复杂度，咕咕咕