Java单例模式的6种实现方式详解

Mason

发布时间：2026-10-16 | 5人浏览过

原创

单例模式是Java中最常用的设计模式之一，旨在确保一个类仅有一个实例并提供全局访问点。本文将深入剖析饿汉式、懒汉式、DCL双重检查、静态内部类、枚举单例及容器管理这六种实现方式，对比其优缺点与线程安全特性，帮助你选出最合适的实现方案。

为什么使用单例模式

单例模式的核心目标是控制实例数量。当需要确保某个类只有一个对象时，或创建该类对象消耗资源过多（如频繁访问IO、数据库连接池初始化等），使用单例模式可以有效节省系统资源并统一管理状态。

使用单例模式的关键原则

私有构造函数：将构造方法访问修饰符设置为 private，防止外部通过 new 关键字直接实例化。
静态获取入口：通过静态方法或枚举返回唯一的类实例。
线程安全保证：确保在多线程环境下，单例对象有且仅有一个实例。
反序列化安全：防止对象在反序列化过程中被重新构建，破坏单例性。

单例模式的几种常见写法

第1步：饿汉式（Eager Initialization）

饿汉式是在类加载时就完成实例化，天然线程安全，但可能造成资源浪费。

public class Singleton {
    // 类加载时即创建实例
    private static Singleton instance = new Singleton();
    
    // 私有构造
    private Singleton() {}
    
    public static Singleton getInstance() {
        return instance;
    }
}

优点：实现简单，线程安全，无锁开销。
缺点：类加载即初始化，若实例较大或不常用，会浪费内存资源。

第2步：懒汉式（Lazy Initialization with Sync）

懒汉式在第一次调用时才创建实例，但简单的同步会导致性能下降。

public class Singleton {
    private static Singleton instance;
    
    private Singleton() {}
    
    // 全方法同步，效率低
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点：延迟加载，节省资源。
缺点：每次调用 getInstance() 都进行同步锁检查，在高并发场景下性能较差，通常不推荐使用此基础版本。

第3步：DCL（Double Check Locking）

DCL模式通过两次判空减少同步次数，兼顾了延迟加载和性能，是经典的工业级实现。

public class Singleton {
    // volatile 防止指令重排导致的不安全问题
    private static volatile Singleton instance = null;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        // 第一层判空：避免不必要的同步
        if (instance == null) {
            synchronized (Singleton.class) {
                // 第二层判空：确保真正创建实例
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

优点：资源利用率高，既延迟初始化又保证线程安全，大部分调用无需加锁，效率高。
注意：必须使用 volatile 关键字修饰实例变量，以禁止指令重排序，否则在JDK 5以前或复杂并发场景下可能失效。

第4步：静态内部类（Static Inner Class）

利用类的加载机制实现延迟加载，兼具安全性和优雅性，是业界推荐的最佳实践之一。

public class Singleton {
    private Singleton() {}
    
    public static Singleton getInstance() {
        // 触发内部类加载，从而初始化 instance
        return SingletonHolder.instance;
    }
    
    private static class SingletonHolder {
        private static Singleton instance = new Singleton();
    }
}

原理：第一次加载 Singleton 类时不会初始化 instance；只有调用 getInstance() 时，才会加载 SingletonHolder 内部类，进而完成初始化。
优点：线程安全，延迟加载，且不需要同步锁，性能优异。

第5步：枚举单例（Enum Singleton）

这是 Effective Java 作者推荐的唯一方式，能绝对防止反射和反序列化攻击。

public enum SingletonEnum {
    INSTANCE;
    
    public void doSomething() {
        System.out.println("do something");
    }
}

优点：代码极简；默认线程安全；JVM 保障序列化机制不会产生新实例，彻底杜绝了反序列化漏洞。
缺点：无法延迟加载（枚举常量在类加载时即初始化）。

第6步：容器管理单例（Manager Pattern）

适用于需要管理多种单例类型的场景，通过统一的 Key-Value 结构进行实例化和管理。

import java.util.HashMap;
import java.util.Map;

public class SingletonManager {
    private static Map<String, Object> objMap = new HashMap<>();
    
    public static void registerService(String key, Object instance) {
        if (!objMap.containsKey(key)) {
            objMap.put(key, instance);
        }
    }
    
    public static Object getService(String key) {
        return objMap.get(key);
    }
}

特点：可以管理多个单例对象，使用时通过 key 获取。
优点：统一接口管理，隐藏具体实现细节，降低耦合度，便于扩展。

总结

在实际开发中，静态内部类和枚举是实现单例模式的首选。静态内部类适合需要延迟加载的场景，而枚举则是最安全、最简洁的防破解方案。DCL模式虽经典，但需注意 volatile 的使用。懒汉式同步版本因性能问题已较少使用，饿汉式则适用于资源消耗小且必然会被使用的场景。以上就是Java单例模式6种实现方式的详细内容，更多关于Java设计模式与并发编程的资料请关注本站其它相关文章！