单例模式概述

单例模式（Singleton Pattern）是设计模式中最基础、最常用的模式之一，其核心目标在于确保一个类在任何情况下仅存在一个实例，并提供全局访问点。这种模式在需要全局唯一资源的场景中尤为重要，例如数据库连接池、线程池、日志管理器等。通过单例模式，可以避免重复创建对象导致的资源浪费，同时确保系统行为的一致性。

单例模式的适用场景

1. 全局唯一资源管理：如配置文件读取器、全局缓存系统等，需要确保所有模块访问的是同一个实例。
2. 控制资源访问：例如打印机管理器，通过单例模式限制同一时间只能有一个打印任务在执行。
3. 共享状态管理：在分布式系统中，单例模式可以用于管理全局状态，如会话管理器。
4. 避免重复创建：对于创建成本高昂的对象（如数据库连接），单例模式可以显著提升性能。

单例模式的实现方式

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

缺点：多线程环境下，可能创建多个实例，破坏单例原则。

3. 线程安全的懒汉式单例（同步方法）

通过同步方法解决线程安全问题，但性能较差。

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

优点：线程安全。
缺点：每次获取实例都需要同步，性能开销大。

4. 双重检查锁定（DCL）

双重检查锁定通过减少同步范围提升性能，但需注意volatile关键字的使用。

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

优点：线程安全，性能较好。
注意点：必须使用volatile防止指令重排序导致的初始化问题。

5. 静态内部类实现

利用类加载机制实现线程安全的懒加载，推荐使用。

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

优点：线程安全，懒加载，实现简单。
原理：静态内部类在第一次被引用时才会加载，确保实例化只发生一次。

6. 枚举实现（推荐）

枚举实现是《Effective Java》作者Josh Bloch推荐的方式，能防止反射攻击和序列化问题。

public enum EnumSingleton {
    INSTANCE;
    public void doSomething() {
        System.out.println("Singleton operation");
    }
}

优点：线程安全，防止反射攻击和序列化问题，实现简洁。
缺点：灵活性较低，无法延迟初始化。

单例模式的优化与注意事项

1. 防止反射攻击

反射机制可以绕过私有构造函数创建新实例，需通过抛出异常防止。

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

2. 序列化与反序列化

单例对象序列化后反序列化会创建新实例，需实现readResolve()方法。

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

3. 线程池与单例的兼容性

在多线程环境中，单例模式需与线程池配合使用，避免因线程复用导致状态混乱。

4. 依赖注入框架的集成

现代开发中，单例模式常与Spring等依赖注入框架结合使用，通过@Singleton注解实现。

@Singleton
public class SpringSingleton {
    // Spring容器保证单例
}

总结与建议

单例模式是实现全局唯一资源管理的有效手段，但需根据具体场景选择合适的实现方式。对于大多数应用，静态内部类实现和枚举实现是最佳选择，兼顾线程安全、性能和简洁性。在涉及序列化和反射的场景中，需额外注意防止破坏单例原则。

实践建议：

1. 优先选择静态内部类或枚举实现。
2. 在需要延迟初始化的场景中，避免使用同步方法。
3. 注意处理序列化和反射攻击问题。
4. 结合依赖注入框架简化单例管理。

通过合理应用单例模式，可以显著提升系统的资源利用率和一致性，是每个开发者必须掌握的核心技能。