Java中的单例模式大盘点：八仙过海各显神通

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。

单例模式是一种创建型设计模式，其目的是确保类只有一个实例，并且提供全局访问点以访问该实例。

在 Java 中，实现单例模式有多种方式，下面介绍其中的一些。

饿汉式单例模式

在饿汉式单例模式中，实例在类加载时就被创建，因此可以保证实例的唯一性。该模式的实现非常简单，可以使用静态初始化器或者私有构造方法来实现。例如：

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

在这个例子中， INSTANCE 是一个静态常量，它在类加载时被初始化为 Singleton 类的实例。getInstance() 方法提供了对该实例的全局访问点。

优点：

• 线程安全，因为实例在类加载的时候就已经创建好了。
• 简单易用，没有线程同步等复杂问题。
• 线程访问单例实例的速度比懒汉式单例模式更快。

缺点：

• 类加载时就创建实例，有可能会浪费资源。
• 如果单例类依赖于其他类，这些依赖的类在类加载时也会被创建，

懒汉式单例模式

在懒汉式单例模式中，实例在第一次使用时才被创建。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

在上面的实现中，instance 是静态变量，用于存储单例对象。在 getInstance 方法中，如果 instance 为 null，则创建一个新的 Singleton 对象，否则直接返回 instance。由于没有进行同步锁定，所以线程不安全，可能会导致并发创建多个实例的问题。

优点：

• 延迟对象的创建时间，减少内存占用。
• 简单易懂，易于实现。

缺点：

• 非线程安全，需要考虑并发情况。
• 多线程环境下，需要使用同步锁或者双重校验锁来保证线程安全，可能会影响性能。

双重校验锁单例模式

“双重检查锁”（Double-Checked Locking） 是懒汉式的一种优化，这种实现方式结合了懒汉式和饿汉式的优点，既能够延迟对象的创建时间，又能够保证线程安全。

public class Singleton {
    private static volatile Singleton INSTANCE;

    private Singleton() {}

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

在这个例子中， INSTANCE 是一个 volatile 的静态变量，它在第一次使用时被创建。getInstance() 方法使用双重检查锁定来确保 INSTANCE 的唯一性。当多个线程同时访问 getInstance() 方法时，只有第一个线程会获得锁定并创建实例。其他线程会等待锁定被释放后再次检查 INSTANCE 是否为空，从而避免了多次创建实例的情况。

需要注意的是，使用 volatile 关键字可以确保 INSTANCE 变量的可见性和有序性，从而保证多线程环境下的正确性。

优点：

• 延迟加载，只有当需要用到实例时才会创建，节省了系统资源。
• 线程安全，适合高并发场景。

缺点：

• 实现复杂，容易出现问题。
• 由于 Java 内存模型的限制，可能会出现指令重排的问题，需要使用 volatile 关键字来解决。

枚举单例模式

枚举单例模式是一种比较新的单例模式实现方式，它在 Java 5 中引入。它利用了 Java 中枚举类型的特性来实现单例模式，枚举类型的每个枚举常量都是单例的。

public enum Singleton {
    INSTANCE;

    public void doSomething() {
        // do something...
    }
}

在这个例子中，枚举类型 Singleton 只有一个枚举常量 INSTANCE ，该常量在枚举类型初始化时被创建。由于枚举类型的实例在 Java 虚拟机中是唯一的，因此枚举常量也是单例的。我们可以通过 Singleton.INSTANCE 来访问该实例，并调用 doSomething() 方法。

优点：

• 简单明了： 枚举单例模式的实现非常简单，而且可以保证线程安全和实例的唯一性。
• 序列化安全： 由于枚举实例在 JVM 中是唯一的，因此可以保证序列化和反序列化的安全性。
• 防止反射攻击： 枚举实例在 JVM 中是唯一的，因此可以避免反射攻击。

缺点：

• 不支持延迟加载 ，因为枚举类型的实例在类加载时就已经被创建了。
• 不能继承其他类 ，因为枚举类型默认继承了Enum类。

静态内部类单例模式

静态内部类单例模式是一种优雅而简洁的实现方式。它利用了 Java 类加载器的机制来保证实例的唯一性，并避免了饿汉式单例模式的缺点。

public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

在这个例子中， Singleton 类的构造方法是私有的，只能在 Singleton 类的内部进行调用。 SingletonHolder 类是 Singleton 类的一个静态内部类，它在 Singleton 类被加载时并不会立即被加载，而是在第一次调用 Singleton.getInstance() 方法时才会被加载，从而实现了延迟加载。

由于静态内部类 SingletonHolder 只会被加载一次，因此 INSTANCE 实例也只会被创建一次，从而保证了实例的唯一性。总的来说，静态内部类单例模式是一种比较优秀的单例模式实现方式，它兼顾了线程安全、懒加载和高效等特点，是一种值得推荐的单例模式实现方式。

优点：

• 线程安全： 静态内部类只会被加载一次，因此可以保证单例对象的线程安全性；
• 懒加载：静态内部类只有在被调用时才会被加载，从而实现了懒加载的效果；
• 高效：静态内部类单例模式没有加锁，所以性能比懒汉式和饿汉式都要高；
• 简单： 静态内部类单例模式的实现比较简单，代码量较少。

缺点：

• 不易理解： 相比于饿汉式和懒汉式，静态内部类单例模式的实现方式可能不太容易理解；
• 无法传递参数： 静态内部类单例模式的构造函数是私有的，无法传递参数。如果需要传递参数，需要使用其他方式实现。

注册式单例模式

注册式单例模式是一种灵活而可扩展的实现方式。在该模式中，单例实例被注册到一个全局的注册表中，可以实现对象的统一管理和获取，但需要注意容器的生命周期和线程安全问题。

下面是一个使用 ConcurrentHashMap 实现注册式单例模式的例子：

public class Singleton {
    private static Map<String, Singleton> instances = new ConcurrentHashMap<>();

    static {
        instances.put(Singleton.class.getName(), new Singleton());
    }

    private Singleton() {}

    public static Singleton getInstance() {
        return instances.get(Singleton.class.getName());
    }

    public static void register(String key, Singleton instance) {
        instances.put(key, instance);
    }

    public static Singleton getRegisteredInstance(String key) {
        return instances.get(key);
    }
}

Spring 框架中的 Bean 注册机制使用的是注册式单例模式。在 Spring 中， Bean 的注册是通过 BeanDefinitionRegistry 接口来完成的，而 BeanDefinitionRegistry 接口的实现类包括了 DefaultListableBeanFactory 和 GenericApplicationContext 等。这些实现类在内部都使用了类似于注册式单例模式的方式来注册和管理 Bean 。

具体来说， Spring 在注册 Bean 时，会将 Bean 的定义信息封装成一个 BeanDefinition 对象，并将其注册到一个全局的 BeanFactory 中，以供后续的使用。在注册 Bean 的过程中， Spring 会根据 BeanDefinition 中的配置信息来创建相应的 Bean 实例，同时还会对其进行依赖注入、生命周期管理等操作。

需要注意的是，Spring 的 Bean 注册机制中，虽然使用了类似于注册式单例模式的方式来管理 Bean ，但它并不是一个完全的单例模式实现。在 Spring 中， Bean 的单例性是在运行时动态实现的，而不是在编译期就确定的。也就是说，如果在 BeanDefinition 中将 scope 属性设置为 prototype ，那么每次获取该 Bean 实例时都会创建一个新的对象，而不是返回同一个单例实例。

优点：

• 可以管理多个单例实例，可以通过名称或者其他方式来获取实例。
• 避免了全局变量带来的问题，比如命名冲突、不同作用域访问困难等。

缺点：

• 容易造成内存泄漏，因为单例实例不会被释放。
• 可能会造成重复创建对象的问题。

ThreadLocal单例模式

ThreadLocal单例模式这种实现方式将单例对象存储在ThreadLocal中，每个线程都有自己的单例对象副本，保证了线程安全。

public class Singleton {
    private static final ThreadLocal<Singleton> singletonThreadLocal = 
        new ThreadLocal<Singleton>() {
            @Override
            protected Singleton initialValue() {
                return new Singleton();
            }
        };

    private Singleton() {}

    public static Singleton getInstance() {
        return singletonThreadLocal.get();
    }
}

在这个示例中，每个线程都有自己的 Singleton 对象副本，使用 ThreadLocal 可以避免线程安全问题。

优点：

• 每个线程都有自己的单例对象副本，线程安全。
• 可以避免锁竞争，提高性能。

缺点：

• 可能会导致内存泄漏问题，需要注意对象的生命周期。

CAS单例模式

CAS单例模式这种实现方式利用了CAS原子操作的特性，可以保证线程安全，但需要注意性能问题。

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    Singleton temp = new Singleton();
                    if (compareAndSetInstance(null, temp)) {
                        instance = temp;
                    }
                }
            }
        }
        return instance;
    }

    private static boolean compareAndSetInstance(Singleton expect, Singleton update) {
        return Unsafe.getUnsafe().compareAndSwapObject(Singleton.class, 
            Unsafe.objectFieldOffset(Singleton.class, "instance"), expect, update);
    }
}

在这个示例中，使用了 volatile 和 CAS 原子操作来保证线程安全，同时实现了懒加载。需要注意的是，使用 Unsafe 类需要特殊权限，并且 CAS 实现的复杂度比较高，适用于高并发场景。

优点：

• 线程安全，高并发场景性能较好。

缺点：

• 实现复杂，需要理解 CAS 原子操作。
• 需要使用 Unsafe 类，需要特殊权限。
• 适用于高并发场景，对于低并发场景可能没有明显的性能优势。

总结

总之，单例模式是一种非常常用的设计模式，可以确保类只有一个实例，并提供全局访问点以访问该实例。在 Java 中，有多种方式可以实现单例模式，开发者可以根据实际需要选择适合自己的实现方式。