深入Java面试：手写单例模式全解析

在Java面试中，设计模式是考察开发者基础功底和代码设计能力的重要环节，而单例模式作为最简单且最常用的设计模式之一，几乎成为了每个Java开发者必须掌握的知识点。本文将详细讲解如何手写单例模式，包括其实现方式、优缺点分析以及面试中可能遇到的陷阱，帮助你全面掌握这一面试必备技能。

一、单例模式概述

单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式常用于需要控制资源访问、共享资源或全局配置的场景，如数据库连接池、线程池、日志记录器等。

二、单例模式的实现方式

1. 饿汉式单例

饿汉式单例在类加载时就完成了初始化，因此是线程安全的。但由于它在类加载时就创建了实例，如果实例未被使用，会造成资源浪费。

public class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    private EagerSingleton() {}
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

优点：实现简单，线程安全。
缺点：可能造成资源浪费。

2. 懒汉式单例（非线程安全）

懒汉式单例在第一次调用getInstance()方法时才创建实例，但基本的懒汉式实现是非线程安全的。

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

问题：多线程环境下，可能创建多个实例。
解决方案：加锁。

3. 懒汉式单例（线程安全，同步方法）

通过在getInstance()方法上加synchronized关键字，可以保证线程安全，但每次获取实例时都需要同步，性能较差。

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

优点：线程安全。
缺点：性能较差。

4. 双重检查锁（DCL）

双重检查锁通过两次检查实例是否为空，并结合synchronized关键字，既保证了线程安全，又提高了性能。

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

关键点：使用volatile关键字防止指令重排序。
优点：线程安全，性能较好。
缺点：实现稍复杂。

5. 静态内部类单例

静态内部类单例利用了类加载机制来保证初始化实例时的线程安全，且只有当调用getInstance()方法时才会加载内部类，从而创建实例。

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

优点：线程安全，延迟加载，实现简单。
缺点：无法防止反射攻击。

6. 枚举单例

枚举单例是《Effective Java》作者Josh Bloch推荐的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象和反射攻击。

public enum EnumSingleton {
    INSTANCE;
    public void doSomething() {
        // 业务方法
    }
}

优点：线程安全，防止反射攻击和反序列化问题。
缺点：不够灵活，无法延迟加载。

三、面试中可能遇到的陷阱

1. 序列化与反序列化问题：单例对象在序列化后再反序列化会创建新的对象，破坏单例。解决方案是实现readResolve()方法。
2. 反射攻击：通过反射可以调用私有构造器创建新实例。解决方案是在构造器中检查实例是否存在，若存在则抛出异常。
3. 多线程环境下的性能问题：如基本的懒汉式单例性能较差，需考虑双重检查锁或静态内部类实现。

四、总结与建议

• 根据场景选择实现方式：如果对性能要求不高且希望实现简单，可以选择饿汉式或静态内部类；如果对性能有较高要求，可以选择双重检查锁；如果需要防止反射攻击和反序列化问题，可以选择枚举单例。
• 注意线程安全：在多线程环境下，必须确保单例模式的线程安全性。
• 考虑序列化和反射：如果单例对象可能被序列化或反射攻击，需采取相应措施。

通过本文的讲解，相信你已经对Java中的单例模式有了全面的了解。在面试中，不仅要能够手写出正确的单例模式实现，还要能够分析其优缺点，并根据实际场景选择合适的实现方式。希望这篇文章能帮助你在Java面试中脱颖而出！