Java单例模式完全指南：7种实现方式与线程安全解决方案

在面向对象编程中，单例模式是最常用的设计模式之一。它确保一个类只有一个实例，并提供一个全局访问点。本文将全面探讨Java中单例模式的实现方式、应用场景以及在不同环境下的最佳实践。

一、单例模式概述

单例模式(Singleton Pattern)是一种创建型设计模式，主要解决以下两个问题：
1. 保证一个类仅有一个实例
2. 提供该实例的全局访问点

这种模式在需要控制资源访问、配置管理、线程池等场景中特别有用。在Java中，实现单例模式需要考虑类加载机制、线程安全、序列化等问题。

二、基础实现方式

1. 饿汉式

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

    private EagerSingleton() {}

    public static EagerSingleton getInstance() {
        return instance;
    }
}

优点：实现简单，线程安全
缺点：类加载时就创建实例，可能造成资源浪费

2. 懒汉式(非线程安全)

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {}

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

优点：延迟加载
缺点：多线程环境下不安全

三、线程安全实现方案

1. 同步方法

public synchronized static Singleton getInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
}

优点：简单直接的线程安全方案
缺点：每次获取实例都需要同步，性能较差

2. 双重检查锁定(DCL)

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;
    }
}

注意：必须使用volatile关键字防止指令重排序

3. 静态内部类

public class InnerClassSingleton {
    private InnerClassSingleton() {}

    private static class SingletonHolder {
        private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
    }

    public static InnerClassSingleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

优点：线程安全，延迟加载，实现优雅

4. 枚举实现

public enum EnumSingleton {
    INSTANCE;

    public void doSomething() {
        // 业务方法
    }
}

优点：绝对防止多实例，自动处理序列化

四、高级话题

1. 反射攻击与防御

通过反射可以破坏单例模式，解决方法是在构造函数中添加检查：

private Singleton() {
    if (instance != null) {
        throw new RuntimeException("Use getInstance() method to get the single instance of this class.");
    }
}

2. 序列化问题

实现Serializable接口的单例类在反序列化时会创建新实例。解决方法：

protected Object readResolve() {
    return getInstance();
}

3. 在Spring框架中的应用

Spring默认使用单例作用域，但不同于传统单例模式：
- 每个容器一个实例
- 基于BeanFactory实现
- 可以通过@Scope注解配置

五、性能考量

不同实现方式的性能差异：
1. 饿汉式：启动时开销
2. 同步方法：每次调用同步开销
3. DCL：第一次调用后无同步开销
4. 静态内部类：平衡的选择

六、实际应用建议

1. 简单场景：枚举或静态内部类
2. 需要延迟加载：DCL或静态内部类
3. Spring环境：优先使用容器管理的单例
4. 明确序列化需求：选择枚举实现

七、常见误区

1. 认为单例模式等同于静态类
2. 忽略线程安全问题
3. 过度使用单例导致代码耦合
4. 忽视单例的生命周期管理

八、替代方案

在某些情况下，可以考虑：
1. 依赖注入
2. 工厂模式
3. 服务定位器模式

总结：Java单例模式有多种实现方式，各有优缺点。开发者应根据具体需求选择最合适的实现，并注意线程安全、反射攻击、序列化等问题。在现代化框架如Spring中，通常更推荐使用容器管理的单例而非手动实现。