独一无二的设计模式——单例模式（Java实现）

news2025/1/19 3:26:54

1. 引言

亲爱的读者们，欢迎来到我们的设计模式专题，今天的讲解的设计模式，还是单例模式哦！上次讲解的单例模式是基于Python实现（独一无二的设计模式——单例模式（python实现））的，但是目前很多实际系统是通过JAVA实现的，所以今天聊一聊基于JAVA的语言特性，单例模式的实现和应用。

2. 什么是单例模式

单例模式（Singleton Pattern）是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。就像世界上只有一个太阳，我们也希望某些对象在整个应用程序中只有一个实例。单例模式适用于需要全局唯一访问的资源，如数据库连接、配置管理器、日志记录器等。

3. 单例模式的实现（Java）

基本实现

在Java中，单例模式通常使用懒汉式或饿汉式实现，以下讲解四种主要的实现方法：

懒汉式实现，懒汉式单例模式只有在第一次调用`getInstance`方法时才会创建实例：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

详细代码解析

instance静态变量用于存储单例实例，在类加载时，它被初始化为null；
getInstance方法是获取实例的关键，如果instance为空，则创建一个新的实例并返回，否则返回已有的实例；
私有构造函数Singleton()防止类被外部实例化，确保实例只能通过getInstance方法获取。

多线程安全的懒汉式实现，为了应对多线程环境，可以使用同步块来确保线程安全：

public class Singleton {
    private static Singleton instance;
    private static final Object lock = new Object();

    private Singleton() {}

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

详细代码解析

lock是一个同步对象，用于确保在多线程环境下，只有一个线程能够创建实例；
在getInstance方法中使用synchronized块来加锁，确保只有一个线程能够进入创建实例的代码块。

饿汉式实现，饿汉式单例在类加载时就创建实例，相比懒汉式避免了多线程问题：

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

    private Singleton() {}

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

详细代码解析

instance静态变量在类加载时即被初始化，确保实例的唯一性和线程安全；
私有构造函数防止外部实例化。

静态内部类实现，这种方法利用类加载机制，只有在调用`getInstance`时才会创建实例，确保线程安全和延迟加载：

public class Singleton {
    private Singleton() {}

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

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

详细代码解析

SingletonHolder是一个静态内部类，包含了Singleton的唯一实例；
在getInstance方法中返回SingletonHolder.INSTANCE，确保实例的延迟加载和线程安全。

4. 单例模式的应用场景和实例

示例一：配置文件管理

在应用程序中，配置文件通常需要全局访问且不应被重复加载。使用单例模式可以确保配置管理器只有一个实例，从而避免重复加载配置文件。

import java.util.Properties;

public class ConfigurationManager {
    private static ConfigurationManager instance;
    private Properties config;

    private ConfigurationManager() {
        config = new Properties();
    }

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

    public void setConfig(String key, String value) {
        config.setProperty(key, value);
    }

    public String getConfig(String key) {
        return config.getProperty(key);
    }
}

使用示例：

ConfigurationManager configManager = ConfigurationManager.getInstance();
configManager.setConfig("api_url", "https://api.example.com");
System.out.println(configManager.getConfig("api_url"));

示例二：日志记录

日志记录器是单例模式的经典应用之一，通过确保日志记录器的唯一性，我们可以统一管理日志输出，避免多个日志实例之间的混乱：

import java.util.logging.*;

public class LoggerSingleton {
    private static LoggerSingleton instance;
    private Logger logger;

    private LoggerSingleton() {
        logger = Logger.getLogger("singleton_logger");
        ConsoleHandler handler = new ConsoleHandler();
        SimpleFormatter formatter = new SimpleFormatter();
        handler.setFormatter(formatter);
        logger.addHandler(handler);
        logger.setLevel(Level.INFO);
    }

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

    public void log(String message) {
        logger.info(message);
    }
}

使用示例：

LoggerSingleton logger = LoggerSingleton.getInstance();
logger.log("This is a log message.");

5. 单例模式的优缺点

优点

控制实例数量：确保一个类只有一个实例，节省资源；
全局访问点：提供一个全局访问点，方便管理和使用。

缺点

不易扩展：由于单例模式限制了实例的数量，可能不利于扩展；
隐藏依赖关系：单例模式通过全局访问点使用实例，可能导致代码依赖关系不明确，不利于测试。

6. 图示

单例模式的UML图：

+----------------+
|   Singleton    |
+----------------+
| - _instance    |
| - _lock        |
+----------------+
| + getInstance()|
+----------------+