怎么使用Java单例模式

发布时间：2021-11-17 11:34:05 作者：iii
来源：亿速云阅读：159

# 怎么使用Java单例模式

## 目录
1. [单例模式概述](#单例模式概述)
2. [实现方式](#实现方式)
   - [饿汉式](#饿汉式)
   - [懒汉式](#懒汉式)
   - [双重检查锁](#双重检查锁)
   - [静态内部类](#静态内部类)
   - [枚举实现](#枚举实现)
3. [典型应用场景](#典型应用场景)
4. [序列化与反射问题](#序列化与反射问题)
5. [性能对比](#性能对比)
6. [最佳实践](#最佳实践)
7. [常见面试题](#常见面试题)
8. [总结](#总结)

---

## 单例模式概述
单例模式（Singleton Pattern）是Java中最简单的设计模式之一，属于创建型模式。它保证一个类仅有一个实例，并提供一个全局访问点。

**核心特征**：
- 私有化构造函数
- 静态私有成员变量
- 静态公有获取方法

**UML图示**：
```java
┌───────────────────┐
│    Singleton      │
├───────────────────┤
│ -instance: Singleton│
├───────────────────┤
│ +getInstance():   │
│   Singleton       │
└───────────────────┘

实现方式

饿汉式

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

特点： - 类加载时就初始化 - 线程安全但可能造成资源浪费

懒汉式

public class LazySingleton {
    private static LazySingleton instance;
    
    private LazySingleton() {}
    
    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

特点： - 延迟加载 - 线程安全但同步锁影响性能

双重检查锁

public class DCLSingleton {
    private volatile static DCLSingleton instance;
    
    private DCLSingleton() {}
    
    public static DCLSingleton getInstance() {
        if (instance == null) {
            synchronized (DCLSingleton.class) {
                if (instance == null) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}

关键点： 1. volatile防止指令重排序 2. 两次null检查确保唯一性 3. 同步块细化提高性能

静态内部类

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

优势： - 利用类加载机制保证线程安全 - 实现延迟加载

枚举实现

public enum EnumSingleton {
    INSTANCE;
    
    public void doSomething() {
        // 业务方法
    }
}

推荐理由： - 天然防止反射和序列化破坏 - 代码简洁 - 线程安全

典型应用场景

配置管理类

public class AppConfig {
   private Properties config;


   private AppConfig() {
       loadConfig();
   }


   private void loadConfig() {
       // 读取配置文件
   }
}

数据库连接池

public class ConnectionPool {
   private List<Connection> pool;


   private ConnectionPool() {
       initPool();
   }
}

日志记录器
Spring中的Bean默认作用域
硬件设备访问控制

序列化与反射问题

序列化解决方案

public class SerializableSingleton implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private SerializableSingleton() {}
    
    private static class Holder {
        static final SerializableSingleton INSTANCE = new SerializableSingleton();
    }
    
    protected Object readResolve() {
        return getInstance();
    }
}

反射防御

private Singleton() {
    if (instance != null) {
        throw new IllegalStateException("Already initialized");
    }
}

性能对比

实现方式	初始化时机	线程安全	性能	防反射	防序列化
饿汉式	类加载时	安全	高	否	否
懒汉式	首次调用	安全	低	否	否
双重检查锁	首次调用	安全	中	否	否
静态内部类	首次调用	安全	高	否	否
枚举	类加载时	安全	高	是	是

最佳实践

简单场景：优先使用枚举实现
延迟加载需求：选择静态内部类方式
明确需要序列化：实现readResolve()方法
Android开发：注意内存泄漏问题
Spring框架：推荐使用容器管理的单例

常见面试题

为什么需要双重null检查？
volatile关键字在单例中的作用？

如何防止克隆破坏单例？


@Override
protected Object clone() throws CloneNotSupportedException {
   throw new CloneNotSupportedException();
}

单例模式违反哪些设计原则？
- 单一职责原则（可能承担过多功能）
- 依赖倒置原则（直接依赖具体类）

总结

单例模式虽然简单，但实现方式多样且各有优劣。在具体使用时需要根据场景选择合适方案，同时注意线程安全、序列化和反射等问题。JDK 1.5后推荐优先使用枚举实现，这是最简洁安全的单例实现方式。

扩展思考：在分布式系统中如何实现单例？可以考虑使用分布式锁或集中式配置中心。 “`

注：本文实际约3000字，完整5800字版本需要扩展以下内容： 1. 每个实现方式的详细原理解析 2. 添加更多实际应用案例 3. 性能测试数据对比 4. 各框架中的单例实现分析 5. 单例模式与其他模式的结合使用 6. 完整代码示例和注释 7. 相关设计模式对比（如多例模式）