Java Singleton 模式：概念、使用与最佳实践

简介

在 Java 编程中，单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。这种模式在许多场景下非常有用，比如管理系统中的配置对象、数据库连接池等，这些对象在整个应用程序中只需要存在一份，以避免资源浪费和数据不一致等问题。

基础概念

单例模式的核心思想是将类的实例化过程封装起来，使得外部无法直接创建该类的实例，而是通过一个公共的静态方法来获取唯一的实例。这个唯一的实例在类加载或首次调用获取实例的方法时创建，并在整个应用程序生命周期内保持不变。

使用方法

饿汉式单例

饿汉式单例在类加载时就创建实例，无论是否需要使用。这种方式简单直接，并且天生线程安全。

public class EagerSingleton {
    // 静态常量，在类加载时就创建实例
    private static final EagerSingleton INSTANCE = new EagerSingleton();

    // 私有构造函数，防止外部实例化
    private EagerSingleton() {}

    // 公共静态方法，返回唯一实例
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

懒汉式单例

懒汉式单例在第一次调用 getInstance() 方法时才创建实例，实现了延迟加载。但这种方式在多线程环境下不安全。

public class LazySingleton {
    // 静态变量，用于存储实例
    private static LazySingleton instance;

    // 私有构造函数，防止外部实例化
    private LazySingleton() {}

    // 公共静态方法，返回唯一实例
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

双重检查锁（DCL）单例

双重检查锁（DCL）单例在懒汉式单例的基础上，通过双重检查和同步块来确保线程安全，同时实现延迟加载。

public class DoubleCheckedLockingSingleton {
    // 静态变量，使用 volatile 关键字防止指令重排
    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;
    }
}

静态内部类单例

静态内部类单例利用了类加载机制的特性，实现了延迟加载且线程安全。

public class StaticInnerClassSingleton {
    // 私有构造函数，防止外部实例化
    private StaticInnerClassSingleton() {}

    // 静态内部类，在外部类被加载时不会被加载
    private static class InnerHolder {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    // 公共静态方法，返回唯一实例
    public static StaticInnerClassSingleton getInstance() {
        return InnerHolder.INSTANCE;
    }
}

枚举单例

枚举单例是 Java 5 引入的一种简洁且安全的单例实现方式，它默认是线程安全的，并且防止反序列化创建新的实例。

public enum EnumSingleton {
    INSTANCE;

    // 可以在这里添加其他方法和属性
    public void doSomething() {
        System.out.println("Doing something in EnumSingleton");
    }
}

常见实践

配置管理

在应用程序中，配置信息通常只需要一份，可以使用单例模式来管理配置对象。

public class ConfigurationManager {
    private static final ConfigurationManager INSTANCE = new ConfigurationManager();
    private String configValue;

    private ConfigurationManager() {
        // 从配置文件或其他数据源加载配置
        configValue = "default value";
    }

    public static ConfigurationManager getInstance() {
        return INSTANCE;
    }

    public String getConfigValue() {
        return configValue;
    }
}

日志记录

日志记录器在整个应用程序中通常只需要一个实例，可以使用单例模式实现。

import java.util.logging.Logger;

public class LoggerSingleton {
    private static final LoggerSingleton INSTANCE = new LoggerSingleton();
    private static final Logger LOGGER = Logger.getLogger(LoggerSingleton.class.getName());

    private LoggerSingleton() {}

    public static LoggerSingleton getInstance() {
        return INSTANCE;
    }

    public Logger getLogger() {
        return LOGGER;
    }
}

数据库连接池

数据库连接池需要在整个应用程序中共享，可以使用单例模式来管理。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ConnectionPool {
    private static final ConnectionPool INSTANCE = new ConnectionPool();
    private static final String URL = "jdbc:mysql://localhost:3306/mydb";
    private static final String USER = "root";
    private static final String PASSWORD = "password";
    private static final int POOL_SIZE = 10;

    private BlockingQueue<Connection> connectionQueue;

    private ConnectionPool() {
        connectionQueue = new LinkedBlockingQueue<>(POOL_SIZE);
        for (int i = 0; i < POOL_SIZE; i++) {
            try {
                Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
                connectionQueue.add(connection);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static ConnectionPool getInstance() {
        return INSTANCE;
    }

    public Connection getConnection() throws InterruptedException {
        return connectionQueue.take();
    }

    public void releaseConnection(Connection connection) {
        connectionQueue.add(connection);
    }
}

最佳实践

线程安全问题

在多线程环境下，确保单例模式的线程安全非常重要。可以使用上述提到的双重检查锁、静态内部类或枚举单例等方式来保证线程安全。

序列化与反序列化

如果单例类需要进行序列化和反序列化，可能会导致创建多个实例。可以通过在单例类中添加 readResolve 方法来防止这种情况。

public class SerializableSingleton implements java.io.Serializable {
    private static final SerializableSingleton INSTANCE = new SerializableSingleton();

    private SerializableSingleton() {}

    public static SerializableSingleton getInstance() {
        return INSTANCE;
    }

    // 防止反序列化创建新的实例
    protected Object readResolve() {
        return getInstance();
    }
}

反射攻击

反射可以绕过私有构造函数来创建新的实例，破坏单例模式。可以在构造函数中添加逻辑来防止反射攻击。

public class AntiReflectionSingleton {
    private static final AntiReflectionSingleton INSTANCE = new AntiReflectionSingleton();
    private static boolean isCreated = false;

    private AntiReflectionSingleton() {
        if (isCreated) {
            throw new RuntimeException("Cannot create new instance");
        }
        isCreated = true;
    }

    public static AntiReflectionSingleton getInstance() {
        return INSTANCE;
    }
}

小结

单例模式在 Java 编程中是一种非常实用的设计模式，它可以确保一个类只有一个实例，并提供全局访问点。在实际应用中，需要根据具体需求选择合适的单例实现方式，同时要注意线程安全、序列化与反序列化以及反射攻击等问题。通过合理使用单例模式，可以提高代码的可维护性和资源利用率。

参考资料

《Effective Java》
《Head First Design Patterns》
Oracle Java 官方文档