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

🕗 发布于 2024-12-28 08:45 单例模式安全 java

饿汉式单线程安全吗

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

饿汉式单例的实现

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

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

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

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

线程安全的原因

提前实例化：通过在类加载时创建实例，确保了在任何线程访问 getInstance() 方法之前，实例已经被创建。
无同步开销：由于实例在类加载时就已创建，后续的访问不需要任何同步操作，提高了性能。

适用场景

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

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

缺点

饿汉式单例的缺点在于：

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

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

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

懒汉式单例（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，从而各自创建新的实例，导致多个实例存在。

确保线程安全的方式

使用 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() 方法，避免了多个实例的创建。

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

示例说明

单例类：Singleton 类使用静态内部类实现了单例模式，确保了线程安全和延迟初始化。
主函数：
- 定义了一个 Runnable 任务，任务中调用 Singleton.getInstance() 并打印实例的哈希码。
- 启动了三个线程来并发访问单例实例。
- 主线程最后再次调用 getInstance() 并打印该实例的哈希码。

运行结果

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

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

总结

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

原文地址：https://blog.csdn.net/m0_52528565/article/details/144760446

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Harbor（2.3.0）的定制页面与安装（x86 & arm）
下一篇：leetcode 354. 俄罗斯套娃信封问题

springcloud篇2-feign、gateway
说明：（1）日志级别NONE-没有日志BASIC-记录请求的开始和结束时间HEADERS-记录请求的开始和结束时、请求头和响应头FULL-记录请求的开始和结束时、请求头和响应头、请求体和响应体但该方式
阅读更多2024-12-28
JavaScript（三）：数组
当传入一个数字时，创建一个指定长度的空数组，数组的元素为undefined。JavaScript中，数组的元素可以是不同的数据类型，也可以嵌套其他数组。：从数组中提取出一个新的子数组（不修改原数组），
阅读更多2024-12-28
向量组学习
向量组的秩及其线性组合。
阅读更多2024-12-28
Web安全攻防入门教程——hvv行动详解
Web安全攻防是一个动态变化的领域，攻防技术日新月异。在学习Web安全的过程中，掌握基础的安全理论和常见的攻击类型、漏洞防御技术是最基本的要求。通过不断的学习和实践，你能够提升自己的安全攻防能力，保护
阅读更多2024-12-28
神经网络-DenseNet
DenseNet（密集连接卷积神经网络，Densely Connected Convolutional Networks）是一种深度卷积神经网络结构，由 Gao Huang 等人于 2017 年提出。
阅读更多2024-12-28
Llama + Dify，在你的电脑搭建一套AI工作流
最近字节在推Coze，你可以在这个平台制作知识库、制作工作流，生成一个具有特定领域知识的智能体。那么，有没有可能在本地也部署一套这个东西呢？这样敏感数据就不会泄露了，断网的时候也能使用AI。刚好最近L
阅读更多2024-12-28
Python（六）面向对象编程
self。
阅读更多2024-12-28
教师管理系统
教学管理系统
阅读更多2024-12-28
Python-实现tuple和list的转换方式
在Python中，tuple（元组）和list（列表）是两种常见的数据结构，它们之间可以相互转换。
阅读更多2024-12-28
大模型笔记！以LLAMA为例，快速入门LLM的推理过程
导读本文借助llama这个模型快速入门LLM的推理过程，技术细节很多都是通用的，也适合其他的LLM。本篇也可以作为CV快速入门NLP简易指南。本文借助llama这个模型快速入门LLM的推理过程，很多技
阅读更多2024-12-28