前言
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会保证：
-
枚举的构造器是私有的
-
枚举的实例化在静态初始化块中完成，且只执行一次
-
任何通过反射调用枚举构造器的操作都会抛出IllegalArgumentException
3、实际应用
3.1. Spring的Bean管理
场景：Spring容器默认管理的Bean都是单例的
@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. 日志记录器
场景：应用中所有日志记录使用同一个日志管理器
// 实际日志框架使用单例模式
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中，枚举是实现单例模式的最佳实践，除非你需要延迟加载（枚举是类加载时就初始化），否则应该优先考虑使用枚举方式实现单例。
