设计模式之单例模式-个人在线分享

设计模式之单例模式

定义

单例模式（Singleton）是一种创建型设计模式，旨在确保一个类在整个系统中只能有一个实例，并提供一个全局访问点。这一设计模式在许多实际应用中都非常有用，特别是在需要共享资源、管理配置或控制服务访问等场景下。单例模式不仅能节省系统资源，还能提供全局访问接口，从而确保系统的一致性。

使用场景

单例模式适用于多种场景，具体如下：

需要一个唯一的实例： 当一个类应当在系统中只存在一个实例时，例如系统的配置类、日志处理类、数据库连接池等。
节省资源： 由于创建对象可能耗费大量资源，通过单例模式可以控制对象的创建次数，从而节省系统资源。
全局访问点： 提供一个全局访问点来访问某个实例，例如系统中的管理器类，确保整个应用程序都能方便地访问该实例。
控制资源访问： 在分布式系统或多线程环境中，通过单例模式可以确保资源的独占访问，避免并发问题。
状态共享： 某些全局状态需要在多个模块之间共享，使用单例模式可以确保这些状态的一致性和可控性。

示例代码

双重检查锁定

双重检查锁定（Double-Checked Locking）是单例模式的一种实现方式，通过减少同步开销来提高性能，同时确保线程安全。

public class Singleton1 {
    private Singleton1() { }

    private static volatile Singleton1 instance;

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

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Singleton1 instance1 = Singleton1.getInstance();
        System.out.println("instance1 = " + instance1);
        // 通过反序列化破坏
        Singleton1 instance2 = JSON.parseObject(JSON.toJSONString(instance1), Singleton1.class);
        System.out.println("instance2 = " + instance2);
        // 通过反射破坏
        Constructor<Singleton1> constructor = Singleton1.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton1 instance3 = constructor.newInstance();
        System.out.println("instance3 = " + instance3);
    }
}

优点

懒加载： 只有在第一次调用 getInstance() 时，实例才会被创建。
线程安全： 通过双重检查锁定机制保证实例创建的线程安全性。
高性能： 仅在实例未创建时进行同步操作，减少了不必要的同步开销。

缺点

代码复杂： 实现起来相对复杂，增加了代码的维护难度。
反射攻击： 可以通过反射机制破坏单例，尽管可以通过修改构造方法来防止反射攻击，但增加了代码复杂度。

静态内部类

静态内部类（Static Inner Class）利用 Java 的类加载机制实现单例模式。只有在第一次使用时才会加载内部类，从而实现懒加载。

public class Singleton5 {
    private Singleton5() { }

    private static class SingletonInstance {
        private static final Singleton5 INSTANCE = new Singleton5();
    }

    public static Singleton5 getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

优点

懒加载： 通过静态内部类实现懒加载，实例在第一次使用时才会创建。
线程安全： 类加载时由 JVM 保证线程安全性。
实现简单： 代码实现简单易懂，维护起来比较方便。

缺点

反射攻击： 同样可以通过反射机制破坏单例。
过早实例化： 尽管通过静态内部类实现了懒加载，但内部类在类加载时便会实例化。

枚举

枚举（Enum）是一种非常安全和简洁的单例实现方式。枚举类型是线程安全的，并且在任何情况下都不会被反射机制破坏。

public enum Singleton6 {
    INSTANCE;
}

优点

简洁明了： 代码简洁易读，枚举类型自带的单例属性使其实现最为简单。
线程安全： 枚举类型天生线程安全。
防反射攻击： 枚举类型不可被反射机制破坏。
防止反序列化： 枚举类型在反序列化时保证唯一性。

缺点

不支持懒加载： 枚举实例在类加载时就被创建。

工作中遇到的场景

场景一：配置管理

在大型系统中，经常需要一个配置管理器来读取和维护系统的配置信息。配置管理器的实例必须是唯一的，以确保所有模块读取到的配置是一致的。可以通过单例模式来实现：

public class ConfigurationManager {
    private static volatile ConfigurationManager instance;
    private Properties properties;

    private ConfigurationManager() {
        properties = new Properties();
        // 加载配置文件
    }

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

    public String getProperty(String key) {
        return properties.getProperty(key);
    }
}

通过这种方式，系统中的任何模块都可以通过 ConfigurationManager.getInstance() 方法获取唯一的配置管理器实例，并读取配置信息。

场景二：日志记录

日志记录器需要在整个应用程序中只有一个实例，以确保日志的统一管理和输出：

public class Logger {
    private static volatile Logger instance;

    private Logger() { }

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

    public void log(String message) {
        // 记录日志
    }
}

这种实现方式确保了系统中所有的日志记录操作都由同一个日志记录器实例完成，从而保证了日志的统一性和完整性。

场景三：数据库连接池

在数据库应用中，数据库连接池是一个非常重要的组件。数据库连接池管理着数据库连接的创建、分配和释放，确保数据库连接的高效利用。通过单例模式，可以确保数据库连接池在系统中只有一个实例，从而实现对数据库连接的统一管理。

public class DatabaseConnectionPool {
    private static volatile DatabaseConnectionPool instance;
    private DataSource dataSource;

    private DatabaseConnectionPool() {
        // 初始化数据库连接池
    }

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

    public Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
}

通过这种方式，可以确保数据库连接池在系统中唯一存在，避免了多线程环境下的资源竞争问题。

场景四：缓存管理

在某些应用场景中，需要一个全局缓存来存储和管理数据。通过单例模式，可以确保缓存管理器在系统中唯一存在，避免了多线程环境下的缓存不一致问题。

public class CacheManager {
    private static volatile CacheManager instance;
    private Map<String, Object> cache;

    private CacheManager() {
        cache = new HashMap<>();
    }

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

    public void put(String key, Object value) {
        cache.put(key, value);
    }

    public Object get(String key) {
        return cache.get(key);
    }
}

这种实现方式确保了缓存管理器在整个系统中的唯一性和一致性。

场景五：线程池管理

在多线程编程中，线程池是一种非常重要的资源管理方式。通过单例模式，可以确保线程池在系统中唯一存在，从而实现对线程的统一管理和调度。

public class ThreadPoolManager {
    private static volatile ThreadPoolManager instance;
    private ExecutorService executorService;

    private ThreadPoolManager() {
        executorService = Executors.newFixedThreadPool(10);
    }

    public static ThreadPoolManager getInstance() {
        if (instance == null) {
            synchronized (ThreadPoolManager.class) {
                if (instance == null

) {
                    instance = new ThreadPoolManager();
                }
            }
        }
        return instance;
    }

    public void submitTask(Runnable task) {
        executorService.submit(task);
    }
}

通过这种方式，可以确保系统中所有的任务都由同一个线程池管理，从而提高了系统的资源利用率和运行效率。

单例模式的变体和优化

饿汉式单例

饿汉式单例（Eager Initialization Singleton）在类加载时就创建实例，从而避免了多线程同步问题，但可能会在不需要时创建实例。

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

    private EagerSingleton() { }

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

优点

实现简单： 代码实现非常简单，不需要考虑多线程同步问题。
线程安全： 由于实例在类加载时就创建，因此不存在多线程同步问题。

缺点

资源浪费： 如果实例长时间未被使用，会浪费系统资源。
不支持懒加载： 实例在类加载时就被创建，无法实现懒加载。

懒汉式单例

懒汉式单例（Lazy Initialization Singleton）在第一次调用 getInstance() 方法时才创建实例，适合于实例创建开销较大的情况。

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() { }

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

优点

懒加载： 实例在第一次使用时才会创建，避免了资源浪费。
实现简单： 实现起来相对简单，适合小型项目。

缺点

线程安全问题： 需要通过同步来保证线程安全，可能导致性能瓶颈。

线程安全的懒汉式单例

通过同步和双重检查锁定来实现线程安全的懒汉式单例。

public class ThreadSafeLazySingleton {
    private static volatile ThreadSafeLazySingleton instance;

    private ThreadSafeLazySingleton() { }

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

优点

线程安全： 通过双重检查锁定机制保证实例创建的线程安全性。
懒加载： 实例在第一次使用时才会创建，避免了资源浪费。
性能较优： 只有在实例未创建时才进行同步操作，减少了不必要的同步开销。

缺点

实现复杂： 代码实现相对复杂，增加了代码的维护难度。

静态代码块单例

通过静态代码块实现单例模式，在类加载时创建实例，可以进行一些实例化前的预处理操作。

public class StaticBlockSingleton {
    private static final StaticBlockSingleton INSTANCE;

    static {
        try {
            INSTANCE = new StaticBlockSingleton();
        } catch (Exception e) {
            throw new RuntimeException("Exception occurred while creating singleton instance");
        }
    }

    private StaticBlockSingleton() { }

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

优点

实现简单： 代码实现简单，不需要考虑多线程同步问题。
线程安全： 由于实例在类加载时就创建，因此不存在多线程同步问题。
异常处理： 可以在静态代码块中进行实例化前的异常处理。

缺点

资源浪费： 如果实例长时间未被使用，会浪费系统资源。
不支持懒加载： 实例在类加载时就被创建，无法实现懒加载。

注册式单例

注册式单例（Registry Singleton）通过在一个统一的注册表中管理单例实例，实现对不同单例的统一管理。

public class RegistrySingleton {
    private static Map<String, Object> registry = new HashMap<>();

    private RegistrySingleton() { }

    public static synchronized Object getInstance(String className) {
        if (!registry.containsKey(className)) {
            try {
                Class<?> clazz = Class.forName(className);
                registry.put(className, clazz.getDeclaredConstructor().newInstance());
            } catch (Exception e) {
                throw new RuntimeException("Exception occurred while creating singleton instance", e);
            }
        }
        return registry.get(className);
    }
}

优点

统一管理： 通过注册表统一管理多个单例实例，便于维护。
扩展性好： 可以动态添加新的单例实例，扩展性较好。

缺点

实现复杂： 代码实现相对复杂，增加了维护难度。
性能开销： 每次获取实例时都需要查找注册表，可能带来一定的性能开销。

单例模式的注意事项

线程安全

在多线程环境下实现单例模式时，必须考虑线程安全问题。常见的线程安全实现方式包括同步方法、双重检查锁定和静态内部类等。

序列化与反序列化

在实现单例模式时，需要注意序列化和反序列化的问题。标准的单例模式在反序列化时可能会创建新的实例，可以通过实现 readResolve 方法来防止这一问题。

public class SerializedSingleton implements Serializable {
    private static final long serialVersionUID = -7604766932017737115L;

    private SerializedSingleton() { }

    private static class SingletonHelper {
        private static final SerializedSingleton INSTANCE = new SerializedSingleton();
    }

    public static SerializedSingleton getInstance() {
        return SingletonHelper.INSTANCE;
    }

    protected Object readResolve() {
        return getInstance();
    }
}

防止反射攻击

单例模式可以通过反射机制来创建新的实例，从而破坏单例的唯一性。可以通过在构造方法中添加防御性代码来防止反射攻击。

public class ReflectiveSingleton {
    private static volatile ReflectiveSingleton instance;
    private static boolean isInstanceCreated = false;

    private ReflectiveSingleton() {
        if (isInstanceCreated) {
            throw new RuntimeException("Use getInstance() method to create");
        }
        isInstanceCreated = true;
    }

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

单例模式的优缺点总结

优点

唯一实例： 确保系统中只有一个实例，避免了资源的重复占用和冲突。
全局访问点： 提供一个全局访问点，便于在系统中的任何地方访问单例实例。
节省资源： 通过控制实例的创建次数，可以有效节省系统资源。
可扩展性： 可以在单例类中添加全局行为，便于统一管理和扩展。

缺点

实现复杂： 有些实现方式（如双重检查锁定）较为复杂，增加了代码的维护难度。
不支持多实例： 单例模式限制了类的实例数量，不适用于需要多个实例的场景。
测试困难： 由于单例模式的全局状态，在单元测试中可能会遇到困难，特别是在并发测试时。
隐藏依赖关系： 单例模式通过全局访问点隐藏了类与类之间的依赖关系，可能导致代码的可读性和维护性下降。

单例模式的最佳实践

选择合适的实现方式： 根据具体需求选择合适的单例实现方式，如饿汉式、懒汉式、双重检查锁定、静态内部类或枚举。
考虑线程安全： 在多线程环境下实现单例模式时，必须确保线程安全，避免并发问题。
处理序列化与反序列化： 如果需要序列化单例类，必须实现 readResolve 方法，确保反序列化时不会创建新的实例。
防止反射攻击： 通过在构造方法中添加防御性代码，防止通过反射机制破坏单例。
单例类的职责单一： 单例类应尽量保持职责单一，避免将过多的功能集中在一个类中，从而导致代码复杂度增加。

总结

单例模式是一种非常重要的设计模式，通过确保一个类只有一个实例，可以有效控制资源的使用，提高系统的性能和稳定性。在实际应用中，可以根据具体需求选择不同的单例实现方式，如

双重检查锁定、静态内部类和枚举等。同时，需要注意线程安全、序列化与反序列化以及防止反射攻击等问题。通过合理应用单例模式，可以为系统的设计和实现带来诸多益处。

一	二	三	四	五	六	日
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30	31