Java中单例的用法_Java中单例模式的实现

胖枫酱_1676

发布时间：2025-06-19 08:42:04

510人浏览过

来源于php中文网

原创

单例模式确保一个类在整个应用程序中只有一个实例存在。其核心实现方式包括：1.饿汉式在类加载时初始化，线程安全但可能浪费资源；2.懒汉式延迟加载但需同步机制影响性能；3.dcl通过双重校验锁和volatile关键字优化线程安全与性能；4.静态内部类利用类加载机制实现延迟加载和线程安全；5.枚举天然支持线程安全、防止反射和序列化攻击但无法延迟加载。为保证线程安全，dcl需使用volatile防止指令重排序，而饿汉式、静态内部类和枚举本身依赖类加载机制保障安全。防止反射攻击可通过构造函数检查实例或使用枚举实现；防止序列化攻击则通过readresolve方法返回已有实例或使用枚举。单例优点包括节省资源、提供全局访问点和延迟加载，缺点涉及隐藏依赖、测试困难及多线程下的复杂性。适用场景如数据库连接池、配置管理、线程池等，具体实现应根据需求选择。

Java中单例的用法_Java中单例模式的实现

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

保证单例的核心在于控制实例的创建。

解决方案

立即学习“Java免费学习笔记（深入）”；

实现单例模式有几种常见的方式，各有利弊：

饿汉式：

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

    private Singleton() {
        // 防止外部通过new创建实例
    }

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

饿汉式在类加载的时候就完成了初始化，所以是线程安全的。优点是实现简单，线程安全。缺点是如果单例对象从始至终都没用到，会造成资源浪费。

懒汉式：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 防止外部通过new创建实例
    }

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

懒汉式在第一次调用getInstance()方法时才创建实例。优点是延迟加载，只有在真正使用的时候才会创建。缺点是需要使用synchronized关键字来保证线程安全，在高并发场景下性能会受到影响。

双重校验锁（DCL）：

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {
        // 防止外部通过new创建实例
    }

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

DCL在懒汉式的基础上进行了优化，只有在实例未被创建时才进行同步。使用volatile关键字是为了防止指令重排序导致的问题。优点是延迟加载，线程安全，性能较高。缺点是实现较为复杂，需要注意volatile关键字的使用。

静态内部类：

public class Singleton {
    private Singleton() {
        // 防止外部通过new创建实例
    }

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

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

静态内部类利用了类加载机制来保证线程安全，同时实现了延迟加载。优点是延迟加载，线程安全，实现简单。缺点是稍微难以理解。

枚举：
```
public enum Singleton {
    INSTANCE;

    public void doSomething() {
        // ...
    }
}
```
枚举是实现单例模式最简单的方式，并且可以防止反射攻击和序列化攻击。优点是实现简单，线程安全，防止反射攻击和序列化攻击。缺点是不能延迟加载，枚举类型在类加载时就会被初始化。

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

线程安全是单例模式中一个非常重要的考虑因素。如果多个线程同时调用getInstance()方法，可能会导致创建多个实例。上述几种实现方式中，饿汉式、静态内部类和枚举天生就是线程安全的，因为它们在类加载时就已经完成了初始化。懒汉式和DCL需要使用同步机制来保证线程安全。懒汉式使用synchronized关键字，DCL使用双重校验锁和volatile关键字。

为什么DCL需要使用volatile关键字？

java-api-doc-generator

分析 Java Spring Boot 后端 Controller 代码，自动生成 Markdown 格式的接口文档。当用户说“生成 Java 接口文档”、“生成 API 文档”、“从 Spring 代码生成文档”时触发。

下载

volatile关键字的作用是防止指令重排序。在DCL中，instance = new Singleton()这行代码实际上包含了三个步骤：

分配内存空间。
初始化对象。
将instance指向分配的内存空间。

由于指令重排序的存在，步骤2和步骤3的顺序可能被颠倒。如果线程A执行了步骤1和步骤3，但步骤2尚未执行，此时线程B调用getInstance()方法，判断instance不为null，直接返回instance，但此时instance指向的对象尚未初始化，线程B使用该对象可能会出现问题。使用volatile关键字可以防止指令重排序，保证步骤2在步骤3之前执行。

单例模式如何防止反射攻击？

反射攻击是指通过反射机制来绕过单例模式的限制，创建多个实例。对于饿汉式、懒汉式和DCL，可以通过在构造函数中判断实例是否已经存在，如果存在则抛出异常来防止反射攻击。

public class Singleton {
    private static Singleton instance;

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

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

对于静态内部类，由于其构造函数也是私有的，并且无法通过反射访问静态内部类，因此可以防止反射攻击。枚举天生就可以防止反射攻击，因为Java虚拟机保证枚举类型的实例只能被创建一次。

单例模式如何防止序列化攻击？

序列化攻击是指通过序列化和反序列化来绕过单例模式的限制，创建多个实例。当一个单例对象被序列化和反序列化后，会得到一个新的对象，破坏了单例性。为了防止序列化攻击，可以实现readResolve()方法，在反序列化时返回已有的单例对象。

public class Singleton implements java.io.Serializable {
    private static final Singleton instance = new Singleton();

    private Singleton() {
        // 防止外部通过new创建实例
    }

    public static Singleton getInstance() {
        return instance;
    }

    private Object readResolve() {
        return instance;
    }
}

枚举天生就可以防止序列化攻击，因为Java虚拟机保证枚举类型的实例只能被创建一次，即使进行序列化和反序列化，得到的仍然是同一个实例。

单例模式的优缺点是什么？

优点：