Java并发编程（十八）：线程安全的单例模式

大家好，我是欧阳方超，公众号同名。

1 概述

在软件开发中，单例模式是一种常见的设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。在多线程环境下，实现单例模式需要特别注意线程安全问题，避免多个线程同时创建多个实例。

2 不同的单例模式

2.1 饿汉式单例模式

饿汉式单例模式在类加载时就创建了单例示例，因此它天生就是线程安全的，因为类加载过程是由JVM保证线程安全的，所有不会出现多个线程同时创建实例的问题。
示例：

public class EagerSingleton {

    private static final  EagerSingleton instance = new EagerSingleton();
    private EagerSingleton() {}

    public static EagerSingleton getInstance() {
        return instance;
    }
}

优点：实现简单，线程安全，无需额外的同步机制。
缺点：在类加载时就创建实例，可能会造成资源浪费，特别是当实例的创建比较耗时或占用大量资源时。

2.2 双重检查锁定（Double-Checked Locking）单例模式

双重检查锁定单例模式结合了懒汉式和同步的优点，通过两次检查实例是否为null，并在第一次检查后进行同步操作，减少了同步的开销。

public class DoubleCheckedLockingSington {
    private static volatile DoubleCheckedLockingSington INSTANCE;

    private DoubleCheckedLockingSington() {}

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

优点：延迟加载，减少了同步的开销，提高了性能。
缺点：实现相对复杂，需要使用volatile关键字来保证可见性。
为什么需要两次是否为空的检查：
第一次检查if (INSTANCE == null)，在锁外部进行检查，如果实例已经创建，直接返回，不需要获取锁；避免了每次获取实例都要执行同步操作，提高了性能。
第二次检查，在synchronized代码块内部进行检查，假设线程A和线程B同时通过第一次检查（此时instance为null），线程A获得锁，创建实例，释放锁；线程B获得锁，如果没有第二次检查，会再次创建实例，有了第二次检查，可以避免重复创建实例。

2.3 静态内部类单例模式

静态内部类单例模式利用了Java静态内部类的特性，静态内部类在类加载时不会被加载，只有在第一次使用时才会被加载，且类加载过程是线程安全的。

public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {}

    private static class SingletonClassHolder {
        private static final StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }

    public static  StaticInnerClassSingleton getInstance() {
        return SingletonClassHolder.INSTANCE;
    }
}

优点：延迟加载，线程安全，实现简单。
缺点：没有明显的缺点，是一种比较推荐的方式。

3 总结

Java中实现线程安全的单例模式有多种方法，每种方法都有其优缺点。在选择实现方式时，需要根据具体的需求和场景来决定。
我是欧阳方超，把事情做好了自然就有兴趣了，如果你喜欢我的文章，欢迎点赞、转发、评论加关注。我们下次见。