Java 单例模式线程安全问题

Java 单例模式是一种常见的设计模式，它的目的是确保一个类只有一个对象实例，并提供了一个全局唯一的访问点。

单例模式的实现方法有很多，其中最常见的是双重检查锁定（Double-Checked Locking）和静态内部类（Static Inner Class）两种方式。但这些实现方式往往存在线程安全问题，需要特别注意。

1. 双重检查锁定的线程安全问题

双重检查锁定是一种常见的单例模式实现方式，它通过使用一个 volatile 变量和两次判断，确保只有一个实例被创建。

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {}

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

双重检查锁定看起来很好用，但它存在线程安全问题。当多个线程同时调用 getInstance() 方法时，可能会出现以下情况：

• 线程 A 进入 synchronized 代码块，创建了一个新的 Singleton 实例。
• 线程 B 也进入 synchronized 代码块，但此时 instance 已经不为 null，于是直接返回该实例。
• 线程 C 也进入 synchronized 代码块，由于此时 instance 已经不为 null，也直接返回该实例。此时会出现多个实例同时存在的情况。

为了避免这种情况，我们可以将 instance 变量声明为 volatile，这样所有线程都会从主内存中读取该变量的值，而不是线程的本地缓存中。

private volatile static Singleton instance;

2. 静态内部类的线程安全问题

静态内部类是一种更好的单例实现方式，它通过一个静态内部类来持有 Singleton 实例，并通过类加载的特性，确保只有一个实例被创建。

public class Singleton {
    private Singleton() {}

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

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

静态内部类的实现方式看起来很简洁，而且没有使用 synchronized 关键字，因此性能也更好。但是，它也存在一定的线程安全问题。

当 Singleton 类被多个线程同时加载时，可能存在多个 SingletonHolder 实例被创建的情况。这时候，每个 SingletonHolder 实例都会创建一个 Singleton 实例，最终还是会有多个实例存在。为了避免这种情况，我们需要确保 Singleton 类只被加载一次。

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

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

总结

以上就是 Java 单例模式线程安全问题的完整攻略。在实际开发中，我们应该根据具体的需求和情况，选择合适的实现方式，并注意线程安全问题。除了上述两种实现方式外，还可以通过枚举、饿汉式等方式实现单例模式。不同的实现方式有不同的优缺点，需要根据具体情况进行选择。