深入理解单例模式：实例成员的可见性探讨与安全实现-java教程-PHP中文网

深入理解单例模式：实例成员的可见性探讨与安全实现

霞舞

发布： 2025-11-21 16:03:16

原创

431人浏览过

深入理解单例模式：实例成员的可见性探讨与安全实现

单例模式旨在确保一个类在整个应用程序生命周期中只存在一个实例。本文深入探讨了单例模式中实例成员的访问修饰符选择，强调了将实例声明为私有（private）而非公共（public）的重要性。通过分析公共实例可能导致的未初始化访问风险和对单例完整性的破坏，文章提供了标准且安全的单例实现方式，并辅以代码示例，旨在指导开发者构建健壮的单例模式。

1. 单例模式概述

单例模式（Singleton Design Pattern）是创建型设计模式中最简单也最常用的一种。它的核心思想是确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。这在需要协调行为的组件、配置管理器、日志对象或线程池等场景中非常有用，可以避免资源浪费和状态不一致的问题。

2. 实例成员的可见性：为何必须私有？

在实现单例模式时，一个常见的问题是：用于存储单例实例的静态成员变量应该声明为 public 还是 private？从设计原则和安全性角度来看，答案是必须声明为 private。

考虑以下一个不安全的单例实现尝试：

public class UnsafeSingleton {
    public static UnsafeSingleton obj; // 公共实例变量

    private UnsafeSingleton() {
        // 私有构造器
    }

    // 没有提供公共的获取实例方法
}

登录后复制

这种实现存在严重问题：

未初始化访问风险： 如果其他代码直接访问 UnsafeSingleton.obj 而没有经过任何初始化逻辑，例如：
```
UnsafeSingleton instance = UnsafeSingleton.obj; // 此时 obj 仍为 null
instance.doSomething(); // 将导致 NullPointerException
```
登录后复制
由于 obj 是公共的，任何地方都可以直接访问它，但其初始化时机无法得到保证。这使得程序在运行时极易出现空指针异常，且难以追踪。
破坏单例完整性： 尽管构造器是私有的，但如果 obj 被声明为 public，理论上外部代码仍可以对其进行赋值操作（尽管无法直接创建新实例），这可能无意中破坏单例的唯一性或导致意外行为。
缺乏控制： 单例模式的核心在于“控制”实例的创建和获取。将实例成员设为 public 等同于放弃了这种控制，与单例模式的设计初衷相悖。

因此，为了确保单例的健壮性和安全性，实例成员必须是私有的，并通过一个公共的静态方法（通常命名为 getInstance()）来提供受控的访问。

3. 正确实现：私有实例与公共访问方法

一个标准且安全的单例模式实现应该遵循以下原则：

私有化构造器，防止外部直接创建实例。
私有化静态实例变量，防止外部直接访问和修改。
提供一个公共的静态方法，作为获取单例实例的唯一入口。

以下是几种常见的单例模式实现方式：

3.1 懒汉式（线程不安全）

这种实现方式在第一次调用 getInstance() 方法时才创建单例实例。

public class LazySingleton {
    private static LazySingleton instance; // 私有静态实例

    private LazySingleton() {
        // 私有构造器
    }

    public static LazySingleton getInstance() { // 公共静态方法
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

登录后复制

注意事项： 这种实现方式在多线程环境下是不安全的。当多个线程同时判断 instance == null 且都为真时，可能会创建出多个实例，从而破坏单例性。

Alkaid.art

专门为Phtoshop打造的AIGC绘画插件

153

查看详情

3.2 懒汉式（线程安全 - 双重检查锁定）

为了解决懒汉式的线程安全问题，可以使用双重检查锁定（Double-Checked Locking）机制。

public class ThreadSafeLazySingleton {
    private static volatile ThreadSafeLazySingleton instance; // 私有静态实例，使用 volatile 关键字

    private ThreadSafeLazySingleton() {
        // 私有构造器
    }

    public static ThreadSafeLazySingleton getInstance() { // 公共静态方法
        if (instance == null) { // 第一次检查
            synchronized (ThreadSafeLazySingleton.class) { // 同步块
                if (instance == null) { // 第二次检查
                    instance = new ThreadSafeLazySingleton();
                }
            }
        }
        return instance;
    }
}

登录后复制

注意事项：

volatile 关键字是必需的，它确保了 instance 变量在所有线程之间是可见的，并且防止了指令重排序优化可能导致的初始化不完整问题。
双重检查锁定在 Java 5 及更高版本中是可靠的。

3.3 饿汉式（线程安全）

饿汉式单例模式在类加载时就完成了实例的创建，因此天生就是线程安全的。

public class EagerSingleton {
    private static EagerSingleton instance = new EagerSingleton(); // 私有静态实例，在类加载时初始化

    private EagerSingleton() {
        // 私有构造器
    }

    public static EagerSingleton getInstance() { // 公共静态方法
        return instance;
    }
}

登录后复制

注意事项：

优点是简单、线程安全。
缺点是如果单例实例的创建过程比较耗时，或者该实例在应用程序生命周期中不一定会被使用，那么会造成资源浪费。

3.4 静态内部类实现（推荐）

静态内部类实现方式结合了懒汉式和饿汉式的优点，既实现了延迟加载，又保证了线程安全。

public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {
        // 私有构造器
    }

    private static class SingletonHolder { // 静态内部类
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance() { // 公共静态方法
        return SingletonHolder.INSTANCE;
    }
}

登录后复制

工作原理：