【单例模式】饿汉式、懒汉式、静态内部类--简单例子

2024-04-17 03:44
文章标签 简单 模式 单例 静态 懒汉 例子 内部 饿汉

本文主要是介绍【单例模式】饿汉式、懒汉式、静态内部类--简单例子，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

单例模式是⼀个单例类在任何情况下都只存在⼀个实例，构造⽅法必须是私有的、由⾃⼰创建⼀个静态变量存储实例，对外提供⼀个静态公有⽅法获取实例。

目录

一、单例模式

饿汉式

 静态内部类

懒汉式

反射可以破坏单例

道高一尺魔高一丈

枚举

一、单例模式

饿汉式

类⼀加载就创建对象，这种⽅式⽐较常用，但容易产⽣垃圾对象，浪费内存空间。

// 饿汉式
public class HungryMan {private HungryMan(){}private final static HungryMan HUNGRY = new HungryMan();public static HungryMan getInstance(){return HUNGRY;}
}

那么它是如何保证线程安全的呢？它是基于类加载机制避免了多线程的同步问题，但是如果类被不同的类加载器加载就会创建不同的实例。 

优点：线程安全，没有加锁，执⾏效率较⾼。
缺点：不是懒加载，类加载时就初始化，浪费内存空间。

 静态内部类

使用静态内部类来实现单例模式是一种非常优雅且线程安全的方式。

这种方法利用了Java类加载机制的特性，即静态内部类只有在被引用时才会被加载和初始化，从而实现了延迟加载的效果。同时，由于Java虚拟机在类加载的过程中，是单线程的，所以静态内部类初始化过程中的线程安全性得到了保证。

// 静态内部类
public class Holder {private Holder(){}public static class Inner{private static final Holder HOLDER = new Holder();}public static Holder getInstance(){return Inner.HOLDER;}
}

 在这个例子中，Holder 类是我们要实现单例的类。我们将其构造函数私有化，以防止外部代码直接通过 new Holder () 来创建实例。然后，我们创建了一个私有的静态内部类 Inner ，它包含一个静态的 Holder 实例。外部代码无法直接访问这个内部类，但是可以通过调用 Holder .getInstance() 方法来获取单例实例。

当 Holder .getInstance() 方法被调用时，Inner 类会被加载和初始化（如果尚未加载的话），这个过程是由Java虚拟机在单线程环境中完成的，因此是线程安全的。在 Inner 类被初始化的过程中，静态变量 INSTANCE 会被创建，并且只会被创建一次。因此，Holder .getInstance() 方法总是返回同一个 Holder 实例，从而实现了单例模式。

懒汉式

懒汉式是一种单例模式的实现方式。这种方式的核心思想是延迟加载，也就是在真正需要使用到实例对象时才进行创建，而不是在程序启动时就创建。这种方式可以节省系统资源，提高程序的运行效率。

在懒汉式单例模式中，会将对象的创建过程放到一个静态方法中，并在这个方法中进行同步控制，以保证在多线程环境下仍然只创建一个实例。当程序第一次调用该方法时，会检查实例是否已经创建，如果没有，则进行创建；如果已经创建，则直接返回已经创建的实例。

// 懒汉式
public class LayMan {private LayMan(){}private static volatile LayMan layMan;// 双层检测锁模式public static LayMan getInstance(){if(layMan == null){synchronized (LayMan.class){if(layMan == null){layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间}}}return layMan;}public static void main(String[] args) {for (int i = 0; i < 10; i++) {new Thread(()->{LayMan.getInstance();}).start();}}
}

那么它是如何保证线程安全呢？通过 synchronized 关键字加锁保证线程安全， synchronized 可以添加在⽅法上⾯，也可以添加在代码块上⾯，存在的问题是每⼀次调⽤ getInstance 获取实例时都需要加锁和释放锁，这样是⾮常影响性能的。

在单线程下使⽤没有问题，但是， 对于多线程是⽆法保证单例的

懒汉式单例模式的主要优点是它的延迟加载特性，可以在系统启动时减少不必要的资源消耗。然而，由于需要进行同步控制，懒汉式单例模式在多线程环境下的性能可能会受到一定影响。此外，如果实现不当，懒汉式单例模式也可能会存在线程安全问题。

---》优点：懒加载，缺点：线程不安全

但是还是不安全，可以通过反射来破坏单例。

反射可以破坏单例

反射破坏单例模式的方式主要是通过访问并调用类的私有构造函数来创建新的实例。在单例模式中，通常会将构造函数设为私有，以防止外部代码创建类的多个实例。然而，使用Java反射API，可以绕过这些访问限制。

具体来说，反射破坏单例模式的步骤如下：

  1. 获取单例类的Class对象。这可以通过调用Class.forName()方法或使用.class语法来完成。

  2. 使用Class对象的getDeclaredConstructor()方法来获取私有构造函数的Constructor对象。这个方法可以访问类中的所有构造函数，无论它们是公有还是私有。

  3. 调用Constructor.setAccessible(true)方法来允许访问私有构造函数。这将取消Java语言的访问检查，使得即使构造函数是私有的，也可以被调用。

  4. 最后，使用Constructor.newInstance()方法来创建单例类的新实例。

这样，即使单例类的构造函数是私有的，也可以通过反射来创建多个实例，从而破坏单例模式的约束。

（1）

import java.lang.reflect.Constructor;// 懒汉式
public class LayMan {private LayMan(){}private static volatile LayMan layMan;// 双层检测锁模式public static LayMan getInstance(){if(layMan == null){synchronized (LayMan.class){if(layMan == null){layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间}}}return layMan;}public static void main(String[] args) throws Exception {LayMan instance1 = LayMan.getInstance();Constructor<LayMan> declaredConstructor = LayMan.class.getDeclaredConstructor();declaredConstructor.setAccessible(true);LayMan instance2 = declaredConstructor.newInstance();System.out.println(instance1);System.out.println(instance2);}
}

从代码运行结果可以看的，拿到了两个不同的实例： 

（2）

import java.lang.reflect.Constructor;// 懒汉式
public class LayMan {private LayMan(){}private static volatile LayMan layMan;// 双层检测锁模式public static LayMan getInstance(){if(layMan == null){synchronized (LayMan.class){if(layMan == null){layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间}}}return layMan;}public static void main(String[] args) throws Exception {Constructor<LayMan> declaredConstructor = LayMan.class.getDeclaredConstructor();declaredConstructor.setAccessible(true);LayMan instance2 = declaredConstructor.newInstance();LayMan instance3 = declaredConstructor.newInstance();System.out.println(instance3);System.out.println(instance2);}
}

从代码运行结果可以看的，拿到了两个不同的实例：  

道高一尺魔高一丈

（1）为了防止反射破坏单例模式，可以采取一些防御措施。例如，在构造函数中添加检查，如果已经存在实例，则抛出异常。

import java.lang.reflect.Constructor;// 懒汉式
public class LayMan {private LayMan(){synchronized (LayMan.class){if(layMan != null){throw new RuntimeException("不用试图使用反射破坏单例");}}}private static volatile LayMan layMan;// 双层检测锁模式public static LayMan getInstance(){if(layMan == null){synchronized (LayMan.class){if(layMan == null){layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间}}}return layMan;}public static void main(String[] args) throws Exception {LayMan instance1 = LayMan.getInstance();Constructor<LayMan> declaredConstructor = LayMan.class.getDeclaredConstructor();declaredConstructor.setAccessible(true);LayMan instance2 = declaredConstructor.newInstance();System.out.println(instance1);System.out.println(instance2);}
}

（2）但是，简单的在构造方法里判断layMan是否是null，如果是通过反射创建的2个实例，就可以通过反射进行破坏了。

import java.lang.reflect.Constructor;// 懒汉式
public class LayMan {private LayMan(){synchronized (LayMan.class){if(layMan != null){throw new RuntimeException("不用试图使用反射破坏单例");}}}private static volatile LayMan layMan;// 双层检测锁模式public static LayMan getInstance(){if(layMan == null){synchronized (LayMan.class){if(layMan == null){layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间}}}return layMan;}public static void main(String[] args) throws Exception {Constructor<LayMan> declaredConstructor = LayMan.class.getDeclaredConstructor();declaredConstructor.setAccessible(true);LayMan instance2 = declaredConstructor.newInstance();LayMan instance3 = declaredConstructor.newInstance();System.out.println(instance3);System.out.println(instance2);}
}

从代码运行结果可以看的，拿到了两个不同的实例：  

（3）红绿灯方法：设置一个标志位flag

但是，简单的在构造方法里判断l标志位flag是否被修改过，也可以通过反射进行破坏。

import java.lang.reflect.Constructor;// 懒汉式
public class LayMan {private static boolean flag = false;private LayMan(){synchronized (LayMan.class){if(flag == false){flag = true;} else {throw new RuntimeException("不用试图使用反射破坏单例");}}}private static volatile LayMan layMan;// 双层检测锁模式public static LayMan getInstance(){if(layMan == null){synchronized (LayMan.class){if(layMan == null){layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间}}}return layMan;}public static void main(String[] args) throws Exception {
//    LayMan instance1 = LayMan.getInstance();Constructor<LayMan> declaredConstructor = LayMan.class.getDeclaredConstructor();declaredConstructor.setAccessible(true);LayMan instance2 = declaredConstructor.newInstance();LayMan instance3 = declaredConstructor.newInstance();System.out.println(instance3);System.out.println(instance2);}
}

（4）相应的，我们也可以通过反射对这个标志位flag进行修改。

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;// 懒汉式
public class LayMan {private static boolean flag = false;private LayMan(){synchronized (LayMan.class){if(flag == false){flag = true;} else {throw new RuntimeException("不用试图使用反射破坏单例");}}}private static volatile LayMan layMan;// 双层检测锁模式public static LayMan getInstance(){if(layMan == null){synchronized (LayMan.class){if(layMan == null){layMan = new LayMan();  // 不是一个原子性操作：分配内存空间、执行构造方法，初始化对象、把这个对象执行空间}}}return layMan;}public static void main(String[] args) throws Exception {
//    LayMan instance1 = LayMan.getInstance();Field f = LayMan.class.getDeclaredField("flag");f.setAccessible(true);Constructor<LayMan> declaredConstructor = LayMan.class.getDeclaredConstructor();declaredConstructor.setAccessible(true);LayMan instance2 = declaredConstructor.newInstance();f.set(instance2, false);LayMan instance3 = declaredConstructor.newInstance();System.out.println(instance3);System.out.println(instance2);}
}

从代码运行结果可以看的，拿到了两个不同的实例：  

枚举

另外，还可以通过枚举类来实现单例，因为枚举类在Java中是天然的单例，且能够抵御反射攻击。

import java.lang.reflect.Constructor;public enum EnumSingle {INSTANCE;public EnumSingle getInstance(){return INSTANCE;}
}class Test{public static void main(String[] args) {EnumSingle instance1 = EnumSingle.INSTANCE;EnumSingle instance2 = EnumSingle.INSTANCE;System.out.println(instance1);System.out.println(instance2);Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);declaredConstructor.setAccessible(true);EnumSingle instance3 = declaredConstructor.newInstance();System.out.println(instance3);}
}

从代码运行结果可以看的，拿到了两个不同的实例：  

并且也可以看到，枚举类里是没有一个无参构造方法的。

在Java中，枚举类保证单例的方式是通过Java语言规范和Java虚拟机（JVM）的内部机制来实现的。具体来说，有以下几点保证了枚举类的单例特性：

  1. 语言级别的保障：Java枚举类型在设计时就被定义为单例的。Java语言规范中明确指出，枚举常量在Java中是由静态final字段表示的，它们在第一次被使用时初始化，并且由于它们是静态的，因此只会被初始化一次。

  2. 线程安全：枚举常量的加载和初始化是由JVM在类加载的过程中完成的，这个过程是线程安全的。由于Java虚拟机提供了类加载机制的安全性，因此不需要额外的同步措施来确保枚举常量的线程安全初始化。

  3. 反射的限制：即使使用Java反射API，也无法创建枚举的额外实例。尝试通过反射来调用枚举的构造函数会抛出异常，因为JVM不允许这样做。

  4. 序列化的安全性：枚举类默认实现了Serializable接口，并且在序列化时有着特殊的处理。即使枚举实例被序列化后再反序列化，也不会创建新的实例，而是返回已经存在的枚举常量。

  5. 单一实例的保证：由于枚举类型的特性，每个枚举常量在JVM中只有一个实例，不可能通过任何方式创建出第二个相同的实例。

因此，使用枚举实现单例模式是一种非常可靠的方法，它自动处理了多线程环境下的同步问题，并且防止了反射和序列化可能导致的单例破坏。

这篇关于【单例模式】饿汉式、懒汉式、静态内部类--简单例子的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/910708。

相关文章

springboot简单集成Security配置的教程

springboot简单集成Security配置的教程

《springboot简单集成Security配置的教程》：本文主要介绍springboot简单集成Security配置的教程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,... 目录集成Security安全框架引入依赖编写配置类WebSecurityConfig（自定义资源权限规则
阅读更多...
SpringBoot如何通过Map实现策略模式

SpringBoot如何通过Map实现策略模式

《SpringBoot如何通过Map实现策略模式》策略模式是一种行为设计模式,它允许在运行时选择算法的行为,在Spring框架中,我们可以利用@Resource注解和Map集合来优雅地实现策略模式,这... 目录前言底层机制解析Spring的集合类型自动装配@Resource注解的行为实现原理使用直接使用M
阅读更多...
如何使用Python实现一个简单的window任务管理器

如何使用Python实现一个简单的window任务管理器

《如何使用Python实现一个简单的window任务管理器》这篇文章主要为大家详细介绍了如何使用Python实现一个简单的window任务管理器,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起... 任务管理器效果图完整代码import tkinter as tkfrom tkinter i
阅读更多...
C++中函数模板与类模板的简单使用及区别介绍

C++中函数模板与类模板的简单使用及区别介绍

《C++中函数模板与类模板的简单使用及区别介绍》这篇文章介绍了C++中的模板机制,包括函数模板和类模板的概念、语法和实际应用,函数模板通过类型参数实现泛型操作,而类模板允许创建可处理多种数据类型的类,... 目录一、函数模板定义语法真实示例二、类模板三、关键区别四、注意事项 ‌在C++中，模板是实现泛型编程
阅读更多...
Linux系统中配置静态IP地址的详细步骤

Linux系统中配置静态IP地址的详细步骤

《Linux系统中配置静态IP地址的详细步骤》本文详细介绍了在Linux系统中配置静态IP地址的五个步骤,包括打开终端、编辑网络配置文件、配置IP地址、保存并重启网络服务,这对于系统管理员和新手都极具... 目录步骤一：打开终端步骤二：编辑网络配置文件步骤三：配置静态IP地址步骤四：保存并关闭文件步骤五：重
阅读更多...
使用EasyExcel实现简单的Excel表格解析操作

使用EasyExcel实现简单的Excel表格解析操作

《使用EasyExcel实现简单的Excel表格解析操作》：本文主要介绍如何使用EasyExcel完成简单的表格解析操作,同时实现了大量数据情况下数据的分次批量入库,并记录每条数据入库的状态,感兴... 目录前言固定模板及表数据格式的解析实现Excel模板内容对应的实体类实现AnalysisEventLis
阅读更多...
C#原型模式之如何通过克隆对象来优化创建过程

C#原型模式之如何通过克隆对象来优化创建过程

《C#原型模式之如何通过克隆对象来优化创建过程》原型模式是一种创建型设计模式,通过克隆现有对象来创建新对象,避免重复的创建成本和复杂的初始化过程,它适用于对象创建过程复杂、需要大量相似对象或避免重复初... 目录什么是原型模式？原型模式的工作原理C#中如何实现原型模式？1. 定义原型接口2. 实现原型接口3
阅读更多...
大数据spark3.5安装部署之local模式详解

大数据spark3.5安装部署之local模式详解

《大数据spark3.5安装部署之local模式详解》本文介绍了如何在本地模式下安装和配置Spark,并展示了如何使用SparkShell进行基本的数据处理操作,同时,还介绍了如何通过Spark-su... 目录下载上传解压配置jdk解压配置环境变量启动查看交互操作命令行提交应用spark，一个数据处理框架
阅读更多...
MyBatis-Plus中静态工具Db的多种用法及实例分析

MyBatis-Plus中静态工具Db的多种用法及实例分析

《MyBatis-Plus中静态工具Db的多种用法及实例分析》本文将详细讲解MyBatis-Plus中静态工具Db的各种用法,并结合具体案例进行演示和说明,具有很好的参考价值,希望对大家有所帮助,如有... 目录MyBATis-Plus中静态工具Db的多种用法及实例案例背景使用静态工具Db进行数据库操作插入
阅读更多...
Java捕获ThreadPoolExecutor内部线程异常的四种方法

Java捕获ThreadPoolExecutor内部线程异常的四种方法

《Java捕获ThreadPoolExecutor内部线程异常的四种方法》这篇文章主要为大家详细介绍了Java捕获ThreadPoolExecutor内部线程异常的四种方法,文中的示例代码讲解详细,感... 目录方案 1方案 2方案 3方案 4结论方案 1使用 execute + try-catch 记录
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2