Java单例模式不会？手把手教你5种实现方式！

想知道Java单例模式怎么搞？本文手把手教你5种实现方式，助你轻松掌握！单例模式是确保应用程序中只有一个实例存在的关键设计模式，广泛应用于配置管理、数据库连接池等场景，有效避免资源浪费和状态不一致。文章详细讲解了饿汉式、懒汉式、双重校验锁、静态内部类和枚举这五种Java单例模式的实现方法，深入剖析了每种方式的优缺点、线程安全问题以及防止反射攻击的策略。通过本文，你将了解如何根据延迟加载、性能需求和安全考量，选择最适合的单例模式实现方式，写出高效、健壮的Java代码。

单例模式确保一个类在整个应用程序中只有一个实例存在。实现Java单例模式的5种方法：1. 饿汉式在类加载时创建实例，简单且线程安全，但可能浪费资源；2. 懒汉式延迟加载，需加synchronized保证线程安全，但性能较低；3. 双重校验锁通过两次判空和volatile关键字提升性能并保证线程安全，但实现较复杂；4. 静态内部类利用类加载机制实现延迟加载和线程安全，实现简单但稍难理解；5. 枚举由JVM保证线程安全和唯一性，实现简单且防反射攻击，但不能延迟加载。选择方式需根据延迟加载、性能、防反射等场景权衡，如需防止反射破坏，可在构造函数中增加判断或使用枚举。

单例模式，简单来说，就是确保一个类在整个应用程序中只有一个实例存在。这在很多场景下非常有用，比如管理配置信息、数据库连接池，或者线程池等，可以避免资源浪费和状态不一致的问题。

实现Java单例模式的5种方法：

饿汉式

饿汉式是最简单的一种实现方式。它在类加载的时候就创建了唯一的实例。

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

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

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

优点： 简单，线程安全。

缺点： 在类加载的时候就创建实例，如果这个实例一直没用到，会造成资源浪费。

懒汉式

懒汉式延迟了实例的创建，只有在第一次调用getInstance()方法时才会创建实例。

public class Singleton {
    private static Singleton instance;

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

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

优点： 延迟加载，节省资源。

缺点： 线程不安全，需要在getInstance()方法上加synchronized关键字，性能较低。

双重校验锁（DCL）

双重校验锁是对懒汉式的一种改进，它在getInstance()方法中进行了两次判空，可以提高性能。

public class Singleton {
    private volatile static Singleton instance;

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

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

优点： 延迟加载，线程安全，性能较高。

缺点： 实现较为复杂，需要使用volatile关键字防止指令重排序。volatile在这里的作用是确保instance变量的可见性和禁止指令重排序。如果没有volatile，可能会出现线程获取到一个未完全初始化的instance实例。

静态内部类

静态内部类利用了类加载机制，既实现了延迟加载，又保证了线程安全。

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

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

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

优点： 延迟加载，线程安全，实现简单。

缺点： 稍微有些难以理解，需要了解类加载机制。

枚举

枚举是实现单例模式最简单的方式，它由JVM保证线程安全和唯一性。

public enum Singleton {
    INSTANCE;

    public void doSomething() {
        // 具体业务逻辑
    }
}

优点： 实现简单，线程安全，防止反射攻击。

缺点： 不能延迟加载，枚举实例在类加载时就会创建。

如何选择合适的单例模式实现方式？

选择哪种单例模式的实现方式取决于具体的应用场景。

• 如果对资源比较敏感，希望延迟加载，可以选择双重校验锁或静态内部类。
• 如果对性能要求很高，可以选择饿汉式或枚举。
• 如果需要防止反射攻击，可以选择枚举。

单例模式在多线程环境下如何保证线程安全？

在多线程环境下，线程安全是单例模式需要重点关注的问题。

• 饿汉式和枚举由于在类加载时就创建了实例，所以天生就是线程安全的。
• 懒汉式需要使用synchronized关键字来保证线程安全，但会降低性能。
• 双重校验锁通过两次判空和volatile关键字来保证线程安全，同时提高性能。
• 静态内部类利用类加载机制来保证线程安全。

如何防止单例模式被反射破坏？

反射可以破坏单例模式的唯一性，通过以下方式可以防止反射攻击：

• 在构造函数中判断是否已经存在实例，如果存在则抛出异常。
• 使用枚举实现单例模式，因为枚举由JVM保证唯一性，反射无法创建新的实例。

下面是构造函数中判断实例是否存在的代码示例：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        if (instance != null) {
            throw new IllegalStateException("Singleton instance already exists.");
        }
    }

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

单例模式的优缺点有哪些？

优点：

• 确保一个类只有一个实例，节省资源。
• 提供全局访问点，方便访问。
• 可以控制实例的创建过程。

缺点：

• 可能会导致代码的耦合度增加。
• 难以进行单元测试。
• 在多线程环境下需要注意线程安全问题。

除了以上五种，还有没有其他的单例模式实现方式？

虽然上述五种方式是比较常见的单例模式实现方式，但实际上还可以通过其他方式来实现，例如使用ThreadLocal来保证线程内的单例，或者使用容器（如Spring）来管理单例Bean。这些方式在特定的场景下可能会更加适用，但需要根据具体的需求进行选择。例如，Spring的单例Bean其实是容器级别的单例，而不是JVM级别的单例。

以上就是《Java单例模式不会？手把手教你5种实现方式！》的详细内容，更多关于java,线程安全,单例模式,延迟加载,反射攻击的资料请关注golang学习网公众号！