伪单例类的多实例替代方案探讨：重构方案是否更优？

原实现分析 #

原伪单例类通过静态synchronized方法reload()创建新实例完成重载，核心逻辑是每次重载生成全新对象，旧实例的集合自然保留供对比。但存在明显问题：

• 内存泄漏风险：若其他代码持有旧实例的引用，旧实例无法被GC回收，长期重载会积累无用对象。
• 线程一致性隐患：实例切换过程中，不同线程可能同时持有新旧实例，导致数据对比或业务逻辑出现不一致。
• 违反单一职责：静态方法与实例状态强耦合，不符合面向对象设计原则，扩展维护性差。

原实现代码：

public class PseudoSingleton {
    private List<Object> collection1;
    private List<Object> collection2;
    private static PseudoSingleton instance = null;

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

    public static synchronized void reload()  {
        instance = new PseudoSingleton();
    }

    private PseudoSingleton() {
        load();
    }
    
    private void load() {
        //parse some files from disk and fill collections
    }
}

重构方案分析 #

你提出的重构方案将reload()改为非静态方法，直接复用当前实例的集合，并通过getCollection1Copy()提供对比用的副本，优势很明显：

• 避免内存泄漏：始终复用同一个实例，不存在旧实例被持有的问题。
• 符合OOP设计：非静态方法操作实例自身状态，职责更清晰。
• 对比逻辑更明确：通过显式的副本方法，让代码使用者清楚知道如何获取重载前的集合状态。

但需要注意潜在的线程安全问题：如果reload()在清空/加载集合时，其他线程同时读取collection1，可能看到不完整的集合状态。解决方式可以是：

• 在reload()内部先加载新集合到临时变量，再原子替换原集合引用（而非清空再填充）。
• 对集合操作加锁，或者使用线程安全的集合类（如CopyOnWriteArrayList）。

重构后的核心代码：

// 非静态reload方法（优化版）
public synchronized void reload() {
   // 先加载临时集合，再替换原引用，减少锁持有时间
   List<Object> newCollection1 = loadCollection1();
   List<Object> newCollection2 = loadCollection2();
   this.collection1 = newCollection1;
   this.collection2 = newCollection2;
}

// 获取集合副本方法
public List<Object> getCollection1Copy() {
   return new LinkedList<>(collection1);
}

更优编码方式 #

结合两者优势，推荐不可变集合+原子引用替换的方案，既保证线程安全，又简化对比逻辑：

1. 用volatile修饰集合引用，保证多线程下的可见性。
2. load()方法直接生成不可变集合（如Collections.unmodifiableList()），避免外部修改。
3. reload()方法先加载新的不可变集合，再原子替换原引用，无需长时间持有锁。
4. 提供获取当前集合的方法（返回不可变视图），对比时只需先保存旧引用，再调用reload()，最后对比新旧引用指向的集合即可。

示例代码：

public class PseudoSingleton {
    private volatile List<Object> collection1;
    private volatile List<Object> collection2;
    private static final PseudoSingleton INSTANCE = new PseudoSingleton();

    // 饿汉式单例，避免双重检查锁的复杂性
    public static PseudoSingleton getInstance() {
        return INSTANCE;
    }

    public void reload() {
        // 加载过程无需锁，操作的是临时变量
        List<Object> newCollection1 = loadCollection1();
        List<Object> newCollection2 = loadCollection2();
        // 原子替换引用，volatile保证可见性
        this.collection1 = Collections.unmodifiableList(newCollection1);
        this.collection2 = Collections.unmodifiableList(newCollection2);
    }

    // 返回不可变视图，防止外部修改
    public List<Object> getCollection1() {
        return collection1;
    }

    private PseudoSingleton() {
        reload(); // 初始化时调用reload完成加载
    }
    
    private List<Object> loadCollection1() {
        // 解析文件并填充集合，返回可变集合
        List<Object> list = new ArrayList<>();
        // parse logic...
        return list;
    }
    
    private List<Object> loadCollection2() {
        // 同理加载collection2
        return new ArrayList<>();
    }
}

这种方案的好处：

• 线程安全：volatile保证集合引用的可见性，不可变集合避免并发修改问题。
• 对比高效：对比时只需先获取旧集合引用（oldCol1 = getInstance().getCollection1()），调用reload()，再获取新集合引用（newCol1 = getInstance().getCollection1()），直接对比两个不可变集合即可，无需复制。
• 无内存泄漏：始终复用同一个单例实例，不存在旧实例残留问题。
• 代码简洁：去掉了不必要的synchronized锁，性能更优。

结论 #

不建议保留原实现，其内存泄漏和线程一致性问题是硬伤。你的重构方案方向正确，但需要补充线程安全的细节。更推荐采用不可变集合+原子引用替换的方案，兼顾代码质量、线程安全和对比需求。

内容的提问来源于stack exchange，提问作者avrath