Java 单例模式全解析

简介

在 Java 开发中，单例模式（Singleton Pattern）是一种常用的设计模式。它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。单例模式在很多场景下都非常有用，比如配置管理、数据库连接池等，这些场景中通常只需要一个实例来避免资源的浪费和冲突。本文将详细介绍单例模式的基础概念、使用方法、常见实践以及最佳实践。

基础概念

单例模式的核心思想是将类的实例化过程进行严格控制，确保在整个应用程序中，该类只有一个实例存在。为了实现这一点，通常需要满足以下几个条件： - 私有构造函数：防止外部代码通过 new 关键字直接创建该类的实例。 - 静态变量：用于存储该类的唯一实例。 - 公共静态方法：提供一个全局访问点，让外部代码可以获取该类的唯一实例。

使用方法

下面是一个简单的单例模式的实现示例：

// 单例类
public class Singleton {
    // 静态变量，用于存储唯一实例
    private static Singleton instance;

    // 私有构造函数，防止外部直接创建实例
    private Singleton() {}

    // 公共静态方法，用于获取唯一实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        // 获取单例实例
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        // 验证两个实例是否相同
        System.out.println(singleton1 == singleton2); // 输出: true
    }
}

在上述代码中，Singleton 类的构造函数是私有的，外部代码无法直接创建该类的实例。getInstance 方法用于获取该类的唯一实例，如果实例还未创建，则创建一个新的实例；如果已经创建，则直接返回该实例。

常见实践

饿汉式单例

饿汉式单例在类加载时就创建了实例，因此不存在线程安全问题。

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;
    }
}

线程安全的懒汉式单例

为了解决懒汉式单例的线程安全问题，可以使用同步方法。

public class ThreadSafeLazySingleton {
    private static ThreadSafeLazySingleton instance;

    private ThreadSafeLazySingleton() {}

    // 使用 synchronized 关键字保证线程安全
    public static synchronized ThreadSafeLazySingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeLazySingleton();
        }
        return instance;
    }
}

最佳实践

双重检查锁定（Double-Checked Locking）

双重检查锁定是一种高效的线程安全的单例实现方式。

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 SingletonHolder {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

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

枚举单例

枚举单例是最简单、最安全的单例实现方式，它可以防止反射和序列化攻击。

public enum EnumSingleton {
    INSTANCE;

    public void doSomething() {
        System.out.println("Doing something...");
    }
}

使用示例：

public class EnumSingletonTest {
    public static void main(String[] args) {
        EnumSingleton singleton = EnumSingleton.INSTANCE;
        singleton.doSomething();
    }
}

小结

单例模式是一种非常实用的设计模式，它可以确保一个类只有一个实例，并提供全局访问点。在实现单例模式时，需要考虑线程安全、性能等因素。常见的实现方式有饿汉式、懒汉式、双重检查锁定、静态内部类和枚举单例等。其中，枚举单例是最简单、最安全的实现方式，推荐在实际开发中使用。

参考资料

《Effective Java》
《设计模式：可复用面向对象软件的基础》
Java 官方文档

通过本文的介绍，希望读者能够深入理解单例模式的概念和实现方式，并在实际开发中高效地使用单例模式。