Java面向对象编程：单例模式的问题与解决

原创ゝ一世哀愁。 2024-09-23 19:51 10阅读 0赞

在Java的面向对象编程中，单例模式是一种特殊的设计模式，用于保证一个类只有一个实例，并提供一个全局访问点。

问题1：如何实现单例模式？

- 饿汉式：在类加载时就初始化，如静态内部类。
```java
public class Singleton {
    // 饿汉式静态内部类
    private static final Singleton INSTANCE = new Singleton();

public static Singleton getInstance() {
        return INSTANCE;
    }

// 私有构造器防止实例化
    private Singleton() {}
}
```

- 活汉式：在需要时才初始化，如非静态内部类。
```java
public class Singleton {
    // 活汉式非静态内部类
    private SingletonHolder holder;

public static Singleton getInstance() {
        if (holder == null) {
            synchronized (Singleton.class) {
                if (holder == null) {
                    holder = new SingletonHolder();
                }
            }
        }
        return holder.instance;
    }

// 私有构造器防止实例化
    private Singleton() {}

// 隐藏类内部的静态成员（保证线程安全）
    static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();

private SingletonHolder() {}

public static Singleton getInstance() {
            return INSTANCE;
        }
    }
}
```

问题2：单例模式有哪些应用场景？

- 管理系统资源，如数据库连接池。
```java
import java.sql.Connection;

public class ConnectionPool {
    private static final ConnectionPool POOL = new ConnectionPool();

public static synchronized Connection getConnection() {
        if (POOL.connection == null) {
            PoolingConnection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "username", "password");
            POOL.connection = connection;
        }
        return POOL.connection;
    }

// 私有构造器防止实例化
    private ConnectionPool() {}
}
```

- 确保应用中某个特定对象的唯一性，如配置文件读取器。
```java
import java.util.Properties;

public class ConfigReader {
    private static final ConfigReader INSTANCE = new ConfigReader();

public static ConfigReader getInstance() {
        return INSTANCE;
    }

private Properties config;

private ConfigReader() {
        config = loadConfig();
    }

private Properties loadConfig() {
        // 从文件、数据库等加载配置
        return new Properties();
    }

public Properties getConfig() {
        return config;
    }
}
```

问题3：单例模式是否存在性能瓶颈？

- 对于线程安全的实现（如饿汉式或同步方法），不存在性能瓶颈，因为每个请求都会创建一个新的实例。

- 对于非线程安全的活汉式实现，可能存在并发控制风险，从而导致性能瓶颈。例如，多个请求同时访问到尚未初始化的内部类时，可能会抛出异常。

解决这种性能问题的方法通常是使用同步机制（如synchronized关键字）来保证线程安全。或者，对于简单的场景，可以考虑其他设计模式，如工厂模式，来避免创建实例的问题。