Java类的单例模式实现
2021-05-183.1k 阅读
单例模式概述
在软件开发中，单例模式是一种常用的设计模式。它的作用是确保一个类在整个应用程序中只有一个实例，并提供一个全局访问点来获取这个实例。这种模式在许多场景下都非常有用，例如数据库连接池、线程池、日志记录器等，这些场景都需要一个唯一的实例来管理资源，避免重复创建和不必要的资源浪费。
单例模式的核心概念在于：
- 唯一性：一个类只能有一个实例。这意味着无论在应用程序的何处请求该类的实例，得到的都是同一个对象。
- 全局访问点：提供一个静态方法或属性，使得在整个应用程序的任何地方都能够方便地获取到这个唯一的实例。
Java 中实现单例模式的常见方式
在 Java 中，有多种方式可以实现单例模式，每种方式都有其特点和适用场景。下面我们将详细介绍几种常见的实现方式。
饿汉式单例
饿汉式单例是一种比较简单直接的实现方式。在类加载时就创建唯一的实例，无论是否需要使用这个实例。
public class EagerSingleton {
// 类加载时就创建实例
private static final EagerSingleton instance = new EagerSingleton();
// 私有构造函数，防止外部实例化
private EagerSingleton() {
}
// 提供全局访问点
public static EagerSingleton getInstance() {
return instance;
}
}
优点：
- 线程安全：由于实例在类加载时就已经创建，而类加载过程是由 JVM 保证线程安全的，所以饿汉式单例天生就是线程安全的。
- 实现简单：代码简洁明了，容易理解和实现。
缺点：
- 资源浪费：如果这个单例实例在整个应用程序中可能根本不会被使用，那么在类加载时就创建它会造成资源的浪费。
懒汉式单例（非线程安全）
懒汉式单例与饿汉式单例不同，它是在第一次使用时才创建实例，实现了延迟加载。
public class LazySingleton {
private static LazySingleton instance;
private LazySingleton() {
}
public static LazySingleton getInstance() {
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
优点：
- 延迟加载：只有在真正需要使用实例时才创建，避免了不必要的资源消耗。
缺点：
- 线程不安全：在多线程环境下，如果多个线程同时调用
getInstance()方法，并且instance为null，那么可能会创建多个实例，这就违背了单例模式的唯一性原则。例如，当线程 A 和线程 B 同时判断instance为null，然后它们都会执行instance = new LazySingleton();，从而创建两个不同的实例。
懒汉式单例（线程安全 - 同步方法）
为了解决懒汉式单例的线程安全问题，可以在 getInstance() 方法上添加 synchronized 关键字。
public class LazySingletonThreadSafe {
private static LazySingletonThreadSafe instance;
private LazySingletonThreadSafe() {
}
public static synchronized LazySingletonThreadSafe getInstance() {
if (instance == null) {
instance = new LazySingletonThreadSafe();
}
return instance;
}
}
优点：
- 线程安全：通过
synchronized关键字，确保在多线程环境下只有一个线程能够进入getInstance()方法，从而保证了实例的唯一性。
缺点：
- 性能问题：由于
synchronized关键字修饰了整个getInstance()方法，每次调用该方法都需要进行同步操作，即使实例已经创建好了。这在高并发环境下会导致性能瓶颈，因为同步操作会带来额外的开销。
懒汉式单例（线程安全 - 双重检查锁定）
双重检查锁定（Double-Checked Locking，DCL）是一种优化的线程安全懒汉式单例实现方式，既能保证线程安全，又能提高性能。
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;
}
}
原理：
- 第一次
if (instance == null)检查是为了避免不必要的同步操作。当实例已经创建好时，直接返回实例，不需要进入同步块。 - 同步块内的第二次
if (instance == null)检查是为了确保在多线程环境下只有一个线程能够创建实例。即使多个线程同时通过了第一次检查并进入同步块，只有一个线程能够创建实例，其他线程再次检查时会发现实例已经存在，直接返回。 volatile关键字的作用是保证instance变量的可见性。在多线程环境下，当一个线程修改了instance的值，其他线程能够立即看到这个修改。如果没有volatile，可能会出现一个线程创建了实例，但其他线程仍然认为instance为null的情况。
优点：
- 线程安全：通过双重检查和同步块，确保了在多线程环境下实例的唯一性。
- 性能优化：只有在实例未创建时才进行同步操作，减少了不必要的同步开销，提高了性能。
缺点：
- 代码复杂性：相比其他简单的实现方式，双重检查锁定的代码更加复杂，理解和维护起来可能需要更多的精力。
静态内部类单例
静态内部类单例是一种兼顾延迟加载和线程安全的实现方式。
public class StaticInnerClassSingleton {
private StaticInnerClassSingleton() {
}
private static class SingletonHolder {
private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
}
public static StaticInnerClassSingleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
原理：
- 外部类
StaticInnerClassSingleton加载时，并不会立即加载内部类SingletonHolder。只有当调用getInstance()方法时，才会触发内部类的加载。 - 内部类
SingletonHolder中的INSTANCE是在类加载时创建的，由于类加载过程由 JVM 保证线程安全，所以这种方式既实现了延迟加载，又保证了线程安全。
优点：
- 延迟加载：只有在调用
getInstance()方法时才会创建实例，避免了不必要的资源浪费。 - 线程安全：利用 JVM 的类加载机制保证了线程安全，不需要额外的同步操作。
- 实现简洁：代码相对简洁，易于理解和维护。
枚举单例
在 Java 5 之后，枚举类型提供了一种简单而强大的方式来实现单例模式。
public enum EnumSingleton {
INSTANCE;
// 可以在枚举中定义方法和属性
public void doSomething() {
System.out.println("执行某些操作");
}
}
优点：
- 线程安全：枚举类型在 JVM 中是天然线程安全的，并且只会被实例化一次。
- 防止反序列化攻击：普通的单例模式在进行反序列化时可能会创建新的实例，破坏单例的唯一性。而枚举单例在反序列化时，JVM 会保证返回的是同一个枚举实例，从而防止了反序列化攻击。
- 实现简单：代码非常简洁，只需要定义一个枚举实例即可。
缺点：
- 灵活性受限：枚举实例在定义后不能动态改变，这在某些需要动态配置的场景下可能不太适用。
单例模式的应用场景
- 数据库连接池：在应用程序中，数据库连接是一种宝贵的资源。使用单例模式可以确保只有一个数据库连接池实例，避免过多的连接创建和销毁，提高资源利用率和系统性能。
- 线程池：线程池用于管理和复用线程，同样需要一个唯一的实例来进行统一的管理。单例模式可以保证线程池的唯一性，使得在整个应用程序中都能使用同一个线程池。
- 日志记录器：日志记录器通常需要在应用程序的各个部分进行记录操作，使用单例模式可以确保所有的日志都记录到同一个地方，方便管理和查看。
- 配置文件管理器：应用程序的配置信息通常只需要加载一次并在整个应用程序中共享。单例模式可以实现一个配置文件管理器，负责读取和管理配置信息，确保在任何地方获取到的配置都是一致的。
单例模式的注意事项
- 反序列化问题：对于普通的单例模式（除枚举单例外），如果对象被序列化并反序列化，可能会创建新的实例。为了防止这种情况，可以在单例类中实现
readResolve()方法，返回已有的单例实例。
public class SerializableSingleton implements java.io.Serializable {
private static final long serialVersionUID = 1L;
private static SerializableSingleton instance = new SerializableSingleton();
private SerializableSingleton() {
}
public static SerializableSingleton getInstance() {
return instance;
}
// 防止反序列化创建新实例
protected Object readResolve() {
return instance;
}
}
- 反射问题：通过反射机制，攻击者可以调用私有构造函数来创建新的实例，破坏单例模式。为了防止反射攻击，可以在构造函数中添加逻辑，当发现已经创建过实例时抛出异常。
public class ReflectSafeSingleton {
private static ReflectSafeSingleton instance;
private ReflectSafeSingleton() {
if (instance != null) {
throw new RuntimeException("不能通过反射创建实例");
}
}
public static ReflectSafeSingleton getInstance() {
if (instance == null) {
instance = new ReflectSafeSingleton();
}
return instance;
}
}
- 多类加载器问题：在某些应用服务器环境中，可能存在多个类加载器。不同的类加载器会将同一个类视为不同的类，从而导致创建多个单例实例。为了避免这种情况，需要确保整个应用程序使用同一个类加载器来加载单例类。
总结各种实现方式的选择
- 饿汉式单例：适用于单例实例在应用程序启动时就需要创建，并且不会造成资源浪费的场景。由于其简单性和线程安全性，在许多情况下是一个不错的选择。
- 懒汉式单例（非线程安全）：只适用于单线程环境，在多线程环境下绝对不能使用，因为会破坏单例的唯一性。
- 懒汉式单例（线程安全 - 同步方法）：虽然保证了线程安全，但由于同步方法的性能问题，在高并发环境下不太适用，除非对性能要求不高。
- 懒汉式单例（线程安全 - 双重检查锁定）：适用于高并发环境下需要延迟加载的场景，在保证线程安全的同时提高了性能，但代码相对复杂，需要对多线程编程有较深入的理解。
- 静态内部类单例：是一种比较优雅的实现方式，兼顾了延迟加载和线程安全，代码简洁，推荐在大多数情况下使用。
- 枚举单例：适用于需要防止反序列化攻击和对代码简洁性要求较高的场景，尤其是在 Java 5 及以上版本。
在实际应用中，需要根据具体的需求和场景来选择合适的单例模式实现方式。同时，要注意单例模式可能带来的一些问题，如反序列化、反射攻击等，并采取相应的措施来避免这些问题。通过合理地使用单例模式，可以有效地管理资源，提高应用程序的性能和稳定性。
通过对 Java 类的单例模式实现的详细介绍，希望读者能够深入理解各种实现方式的原理、优缺点以及适用场景，在实际开发中能够根据具体需求选择最合适的单例模式实现，编写出更加健壮和高效的代码。同时，对于单例模式可能面临的问题，如反序列化和反射攻击等，也需要有足够的认识并采取相应的防范措施，以确保单例模式的正确性和稳定性。在多线程和复杂的应用环境中，正确地使用单例模式是构建高质量软件系统的重要一环。