设计模式-单例模式

单例模式（Singleton Pattern）是一种常用的设计模式，确保一个类在整个应用程序中只有一个实例，并且提供一个全局访问点来访问这个实例。它的主要目标是控制实例化，避免创建多个实例，以节省资源并保证全局状态的一致性。

在Java中实现单例模式有几种常见的方式：

1. 懒汉式单例（Lazy Initialization Singleton）

实现方式

懒汉式单例是在需要时才创建实例（即延迟加载）。这是通过在首次调用 getInstance() 方法时创建对象的。

public class LazySingleton {// 私有静态实例，尚未初始化private static LazySingleton instance;// 私有构造函数，防止外部实例化private LazySingleton() {}// 提供获取实例的全局访问点public static LazySingleton getInstance() {if (instance == null) {instance = new LazySingleton();  // 在第一次调用时创建实例}return instance;}
}

优点

• 实例在需要时才创建，节省资源。
• 延迟加载，避免程序启动时不必要的实例创建。

缺点

• 线程不安全：如果有多个线程同时访问 getInstance()，可能会导致多个实例被创建。需要进行额外的线程同步处理。

2. 线程安全的懒汉式单例

为了解决懒汉式单例的线程安全问题，可以在 getInstance() 方法上加上同步锁。

public class SynchronizedLazySingleton {private static SynchronizedLazySingleton instance;private SynchronizedLazySingleton() {}// 通过 synchronized 关键字保证线程安全public static synchronized SynchronizedLazySingleton getInstance() {if (instance == null) {instance = new SynchronizedLazySingleton();}return instance;}
}

优点

• 保证了线程安全，不会出现多个实例。

缺点

• 每次调用 getInstance() 都会进行同步操作，可能会导致性能瓶颈，特别是在多线程环境中，大量调用时性能下降明显。

3. 双重检查锁定（Double-Checked Locking）

为了解决同步性能问题，可以使用“双重检查锁定”技术。只在实例为空时才加锁，避免每次调用都进行同步。

public class DoubleCheckedSingleton {private static volatile DoubleCheckedSingleton instance;private DoubleCheckedSingleton() {}public static DoubleCheckedSingleton getInstance() {if (instance == null) {  // 第一次检查synchronized (DoubleCheckedSingleton.class) {if (instance == null) {  // 第二次检查instance = new DoubleCheckedSingleton();}}}return instance;}
}

关键点

• volatile 关键字：确保多个线程正确处理实例变量的可见性。
• 双重检查：通过在同步块内外都进行 null 检查，避免不必要的同步操作。

优点

• 线程安全，同时避免了不必要的同步，提高了性能。

缺点

• 实现较为复杂，理解起来有一定的难度。

4. 饿汉式单例（Eager Initialization Singleton）

实现方式

饿汉式单例是在类加载时就创建实例，而不是在需要时才创建。这是通过直接初始化静态变量来实现的。

public class EagerSingleton {// 类加载时就创建实例private static final EagerSingleton instance = new EagerSingleton();// 私有构造函数，防止外部实例化private EagerSingleton() {}// 提供获取实例的全局访问点public static EagerSingleton getInstance() {return instance;}
}

优点

• 简单，类加载时即创建实例，线程安全。
• 没有锁机制，性能高。

缺点

• 不具备延迟加载特性，可能会在程序不需要该实例时就加载，浪费资源。

5. 静态内部类实现单例（Static Inner Class Singleton）

这种方式利用了Java类加载机制中的延迟加载特性。静态内部类只有在第一次被使用时才会被加载，从而实现懒加载的效果。

public class InnerClassSingleton {private InnerClassSingleton() {}// 静态内部类，只有在被调用时才会装载private static class SingletonHolder {private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();}public static InnerClassSingleton getInstance() {return SingletonHolder.INSTANCE;}
}

原理

• 静态内部类 SingletonHolder 在 getInstance() 方法被调用时才会加载，因此实现了延迟加载。
• 类加载机制保证了线程安全性。

优点

• 延迟加载，线程安全，且实现简单。
• 不需要加锁，性能优越。

缺点

• 和饿汉式类似，加载时耗费时间，如果实例初始化很大，会带来一些性能损耗。

6. 枚举单例（Enum Singleton）

枚举类型是实现单例模式最简单且安全的方法，它不仅避免了反序列化破坏单例，还能防止反射攻击。

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

优点

• 简单明了，Java语言本身提供了枚举的特性，保证了实例的唯一性。
• 线程安全且可以防止序列化和反射攻击。

缺点

• 枚举单例无法懒加载。

总结

单例模式在需要控制某个类的全局唯一实例时非常有用，比如数据库连接池、线程池、配置管理等场景。选择哪种实现方式取决于具体的需求：

• 懒汉式：适合希望延迟加载的场景，但需要考虑线程安全问题。
• 饿汉式：适合在类加载时就需要实例的场景，但无法延迟加载。
• 双重检查锁定：适合需要线程安全且有一定性能要求的场景。
• 静态内部类：实现了懒加载且线程安全，推荐使用。
• 枚举：最简单且安全的实现方式，防止序列化和反射攻击，但无法延迟加载。