单例模式懒汉式、饿汉式（线程安全）

• 饿汉式单线程安全吗

饿汉式单例（Eager Singleton）是线程安全的。这种实现方式在类加载时就创建了单例实例，因此在多线程环境中，不存在多个线程同时创建实例的问题。

饿汉式单例的实现

以下是一个饿汉式单例的示例：

public class EagerSingleton {
    // 在类加载时立即创建实例
    private static final EagerSingleton instance = new EagerSingleton();

    // 私有构造函数
    private EagerSingleton() {
        // Initialization code
    }

    // 提供全局访问点
    public static EagerSingleton getInstance() {
        return instance;
    }
}

线程安全的原因

1. 提前实例化：通过在类加载时创建实例，确保了在任何线程访问 getInstance() 方法之前，实例已经被创建。

2. 无同步开销：由于实例在类加载时就已创建，后续的访问不需要任何同步操作，提高了性能。

适用场景

饿汉式单例适合以下场景：

• 需要确保一定会使用该实例，并且不怕在启动时占用内存。
• 在应用启动时就能确定实例的创建。

缺点

饿汉式单例的缺点在于：

• 可能导致资源浪费：如果实例在运行时并不一定会被使用，它仍然会在启动时占用内存。
• 不支持懒加载：无论是否需要，实例都会在类加载阶段创建。

总之，饿汉式单例是线程安全的，适合特定场景，但在设计时需要根据需求仔细选择实现方式。

---

• 懒汉式加载时线程安全的吗？

懒汉式单例（Lazy Singleton）在默认实现中并不是线程安全的。多个线程同时访问 getInstance() 方法时，可能会导致多个实例的创建。为了确保线程安全，需要采取适当的同步措施。

懒汉式单例的基本实现

以下是一个不安全的懒汉式单例示例：

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // Initialization code
    }

    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton(); // 可能会导致多个线程创建多个实例
        }
        return instance;
    }
}

线程不安全的原因

• 竞态条件：多个线程同时调用 getInstance() 方法时，可能会同时发现 instance 为 null，从而各自创建新的实例，导致多个实例存在。

确保线程安全的方式

1. 使用 synchronized 关键字：

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // Initialization code
    }

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

这种方式确保了在同一时刻只有一个线程可以执行 getInstance() 方法，避免了多个实例的创建。

2. 双重检查锁定（Double-Checked Locking）：

public class LazySingleton {
    private static volatile LazySingleton instance;

    private LazySingleton() {
        // Initialization code
    }

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

volatile 关键字的作用：

• 防止指令重排序：在没有 volatile 的情况下，JVM 可能会对对象的初始化过程进行优化，导致指令重排序。例如，在创建对象时，可能会先返回对象引用，然后再初始化对象。这将导致某些线程可能获取到尚未完全初始化的实例。
  确保可见性：volatile 关键字确保了当一个线程修改 instance 时，其他线程能够立即看到这个变化。这避免了由于线程缓存导致的可见性问题。
• 优点：
  性能优化：使用双重检查锁定可以避免每次调用 getInstance() 时都进行同步，只有在 instance 为 null 时才会加锁。这样在多次调用时，性能开销显著降低。
  延迟初始化：实例仅在第一次调用时创建，避免了实例的早期创建，节省资源。
  适用场景：
  适合需要懒加载的单例模式，特别是在高并发的环境下，能够有效地减少锁的开销。

3.通过静态内部类实现，利用 Java 的类加载机制确保线程安全。

public class Singleton {
    private Singleton() {
        // Initialization code
    }

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

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

使用静态内部类来实现单例模式是一种优雅且高效的方法。以下是这种实现方式的一些主要优点：

• 1. 线程安全
     类加载机制：静态内部类的实例是在第一次调用 getInstance() 方法时加载的，这意味着在类加载过程中不会创建实例，从而确保了线程安全。
     避免同步开销：由于实例在静态内部类中创建，只有在需要时才会被加载，因此不需要在方法上添加同步锁，从而减少了性能开销。
• 2. 延迟初始化
     按需创建：实例仅在第一次调用 getInstance() 时创建，这样可以避免在应用启动时就创建资源，节省了内存和其他资源的使用。
• 3. 避免反序列化问题
     反序列化保护：如果实现了 Serializable 接口，静态内部类的单例实现可以防止通过反序列化创建多个实例。因为反序列化时，静态内部类的静态字段会被正确初始化，确保返回的仍然是同一个实例。
• 4. 简单易读
     代码清晰：静态内部类的实现方式简洁明了，易于理解和维护。相较于其他实现方式（如双重检查锁定），代码量较少，逻辑更加直观。
• 5. 兼容性
     Java 语言特性：这种实现方式利用了 Java 的类加载机制，是一种符合 Java 语言设计的优雅方案，能够很好地与其他 Java 特性结合使用。

总结

默认的懒汉式单例实现是线程不安全的。要确保线程安全，可以使用同步机制或其他设计模式。推荐静态内部类来实现

---

以下是使用静态内部类实现的单例模式的示例，包括一个 main 函数，展示如何调用并验证单例的行为。

单例模式实现

public class Singleton {
    private Singleton() {
        // Initialization code
    }

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

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

主函数示例

public class Main {
    public static void main(String[] args) {
        // 创建多个线程来测试单例
        Runnable task = () -> {
            Singleton instance = Singleton.getInstance();
            System.out.println("Instance HashCode: " + instance.hashCode());
        };

        // 启动多个线程
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        Thread thread3 = new Thread(task);

        thread1.start();
        thread2.start();
        thread3.start();

        // 等待线程执行完成
        try {
            thread1.join();
            thread2.join();
            thread3.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 主线程再次获取实例
        Singleton mainInstance = Singleton.getInstance();
        System.out.println("Main Thread Instance HashCode: " + mainInstance.hashCode());
    }
}

示例说明

1. 单例类：Singleton 类使用静态内部类实现了单例模式，确保了线程安全和延迟初始化。

2. 主函数：

   • 定义了一个 Runnable 任务，任务中调用 Singleton.getInstance() 并打印实例的哈希码。
   • 启动了三个线程来并发访问单例实例。
   • 主线程最后再次调用 getInstance() 并打印该实例的哈希码。

运行结果

你应该会看到所有线程打印的哈希码相同，表明它们获取的是同一个实例。例如：

Instance HashCode: 123456789
Instance HashCode: 123456789
Instance HashCode: 123456789
Main Thread Instance HashCode: 123456789

总结

这个示例展示了如何使用静态内部类实现单例模式，并通过多线程验证了其线程安全性。所有线程和主线程都获取到了同一个实例，验证了单例模式的有效性。