Java单例模式全解析：从基础到推荐的八种实现方式

山间有风

发布时间：2026-10-13| 7人浏览过

原创

单例模式是Java中最常用的设计模式之一，旨在确保一个类仅有一个实例，并提供全局访问点。本文将系统梳理单例模式的八种经典实现方式，涵盖饿汉式、懒汉式及其变种，并深入分析多线程环境下的安全性问题。通过代码示例与原理剖析，帮助开发者理解不同实现的优缺点，从而在实际开发中选择最适合的方案。

什么是单例模式

单例模式（Singleton Pattern）是一种创建型设计模式，其核心目标是控制类的实例化过程，确保整个应用程序中某个类只有一个实例，并为该实例提供一个全局访问点。这种模式广泛应用于数据库连接池、日志记录器、配置管理器等需要共享资源的场景。

单例模式的八种实现方式

根据实例化的时机、线程安全性以及实现复杂度，单例模式主要有以下八种写法。我们将逐一分析其原理、代码结构及适用场景。

1. 饿汉式：静态常量

实现原理

饿汉式是在类加载时就完成实例化，不管你是否使用，实例都已经被创建了。这种方式天然线程安全，因为类加载机制保证了线程安全。

操作步骤

将构造器私有化，防止外部通过 new 关键字创建对象。
在类内部直接创建静态常量实例。
暴露一个静态公共方法 getInstance() 返回该实例。

class Singleton {
    // 构造器私有化
    private Singleton() {}
    
    // 类加载时即创建实例，天然线程安全
    private static final Singleton instance = new Singleton();
    
    // 提供全局访问点
    public static Singleton getInstance() {
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2); // true
    }
}

2. 饿汉式：静态代码块

这种写法与静态常量类似，都是在类加载阶段完成初始化。区别在于实例的创建放在了静态代码块中，适合需要对实例进行复杂初始化的场景。

class Singleton {
    private Singleton() {}
    
    private static Singleton instance;
    
    static {
        instance = new Singleton();
    }
    
    public static Singleton getInstance() {
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2); // true
    }
}

3. 懒汉式：线程不安全（不推荐）

懒汉式的特点是延迟加载，即在第一次调用 getInstance() 时才创建实例。但这种写法在多线程环境下是不安全的，可能出现多个线程同时进入 if (instance == null) 判断，导致创建多个实例。

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

public class Main {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2); // 可能为 false
    }
}

4. 懒汉式：同步方法（效率低，不推荐）

为了解决线程安全问题，可以在 getInstance() 方法上添加 synchronized 关键字。虽然这保证了线程安全，但每次调用都会进行锁竞争，严重影响性能。

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

public class Main {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2); // true
    }
}

5. 懒汉式：同步代码块（无法解决，不推荐）

一种常见的错误做法是将 synchronized 加在 if 语句内部的代码块上。由于 instance = new Singleton() 并非原子操作，且锁只保护了赋值部分，依然会出现线程安全问题。

class Singleton {
    private Singleton() {}
    
    private static Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                instance = new Singleton(); // 非原子操作，存在风险
            }
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2); // 可能为 false
    }
}

6. 双重检查锁定（DCL）—推荐使用

这是生产环境中常用的高性能单例实现方式。它结合了懒汉式的延迟加载和同步方法的线程安全，通过两次 null 检查来减少锁的竞争。关键点在于使用 volatile 关键字禁止指令重排序，保证实例完全初始化后再赋值给引用。

实现要点

instance 必须声明为 volatile。
第一次检查避免不必要的锁获取。
第二次检查在锁内执行，确保只有一个线程创建实例。

class Singleton {
    private Singleton() {}
    
    private static volatile Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {               // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) {       // 第二次检查
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2); // true
    }
}

7. 静态内部类—推荐使用

利用类加载机制实现线程安全和延迟加载。当 Singleton 类被加载时，静态内部类 SingletonInstance 并不会被加载，只有调用 getInstance() 时才会触发内部类的加载和初始化。Java 类加载过程是线程安全的，因此无需额外的同步措施。

class Singleton {
    private Singleton() {}
    
    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

public class Main {
    public static void main(String[] args) {
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();
        System.out.println(s1 == s2); // true
    }
}

8. 枚举单例—最推荐

《Effective Java》作者 Joshua Bloch 强烈推荐使用枚举来实现单例。枚举类型天然线程安全，能防止反射攻击和序列化破坏，且代码简洁。虽然语义上与普通类不同，但其本质也是类。

enum Singleton {
    INSTANCE;
    
    public void doSomething() {
        System.out.println("业务逻辑");
    }
}

public class Main {
    public static void main(String[] args) {
        Singleton s1 = Singleton.INSTANCE;
        Singleton s2 = Singleton.INSTANCE;
        System.out.println(s1 == s2); // true
        s1.doSomething();
    }
}