实现单例模式的常见方式

前言

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