多线程下的单例设计模式（新手必看！！！）

在项目中为了避免创建大量的对象，频繁出现gc的问题，单例设计模式闪亮登场。

一、饿汉式

1.1饿汉式

顾名思义就是我们比较饿，每次想吃的时候，都提前为我们创建好。其实我记了好久也没分清楚饿汉式和懒汉式的区别。这里给出我的一个记忆方法：懒汉式就是懒加载，什么是懒加载呢？就是我们需要的时候给创建对象就行，稍后介绍懒汉式的时候你会发现这个现象。

1.2饿汉式的特点

线程安全，但是如果一个项目需要创建大量的对象的时候，当项目运行的时候，会创建大量我们暂时用不到的对象。

1.3饿汉式代码
package singletonModel;
public class HungrySingleton {public static HungrySingleton instance=new HungrySingleton();private HungrySingleton(){}public static HungrySingleton getInstance(){return instance;}
}
1.4多线程下测试
package Test;
import singletonModel.DoubleLockSingleton;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicReference;
public class SingletonTest {public static void main(String[] args) {// 使用AtomicReference来存储第一次获取到的LazySingleton实例AtomicReference<DoubleLockSingleton> singletonInstance = new AtomicReference<>();// 我们将启动大量线程来尝试突破单例的线程安全性ExecutorService executorService = Executors.newFixedThreadPool(100);// 用于发现多个实例创建的标志AtomicReference<Boolean> flag = new AtomicReference<>(false);// 提交多个任务到线程池，尝试并发地获取单例实例for (int i = 0; i < 100; i++) {executorService.submit(() -> {DoubleLockSingleton instance = DoubleLockSingleton.getInstance();// 如果原子引用为空，我们设置当前实例if (singletonInstance.get() == null) {singletonInstance.set(instance);} else if (singletonInstance.get() != instance) {// 如果原子引用中的实例与当前获取的实例不同，说明存在多个实例flag.set(true);System.out.println("Detected multiple instances!");}});}executorService.shutdown();// 等待所有任务完成while (!executorService.isTerminated()) {// 等待所有线程执行完毕}if (flag.get().equals(false)) {System.out.println("No multiple instances detected!");}}
}
1.5运行结果

在这里插入图片描述

通过实验证明，饿汉式在多线程环境下是线程安全的！

二、懒汉式

2.1懒汉式

顾名思义比较懒，叫我们的时候，我们在穿衣服去干活，即完成对象的创建的过程。

2.2懒汉式的特点

需要的时候，才为我们创建，能够避免在项目启动的时候，创建大量的无用对象，减少GC。缺点就是多线程操作下线程不安全！

2.3懒汉式代码
package singletonModel;
public class LazySingleton {private static LazySingleton lazyInstance;private LazySingleton(){}public static LazySingleton getInstance(){if(lazyInstance==null){lazyInstance= new LazySingleton();}return lazyInstance;}
}
2.4多线程下测试
package Test;
import singletonModel.LazySingleton;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicReference;
public class SingletonTest {public static void main(String[] args) {// 使用AtomicReference来存储第一次获取到的LazySingleton实例AtomicReference<LazySingleton> singletonInstance = new AtomicReference<>();// 我们将启动大量线程来尝试突破单例的线程安全性ExecutorService executorService = Executors.newFixedThreadPool(100);// 用于发现多个实例创建的标志AtomicReference<Boolean> flag = new AtomicReference<>(false);// 提交多个任务到线程池，尝试并发地获取单例实例for (int i = 0; i < 100; i++) {executorService.submit(() -> {LazySingleton instance = LazySingleton.getInstance();// 如果原子引用为空，我们设置当前实例if (singletonInstance.get() == null) {singletonInstance.set(instance);} else if (singletonInstance.get() != instance) {// 如果原子引用中的实例与当前获取的实例不同，说明存在多个实例flag.set(true);System.out.println("Detected multiple instances!");}});}executorService.shutdown();// 等待所有任务完成while (!executorService.isTerminated()) {// 等待所有线程执行完毕}if (flag.get().equals(false)) {System.out.println("No multiple instances detected!");}}
}

上述代码需要多次测试，就能够测试出线程不安全的！

2.5测试结果

在这里插入图片描述
测试证明懒汉式在多线程操作下是线程不安全的！

2.6具体原因

具体的原因就是发生在下图的位置：即多线程环境下，不知线程哪个执行快慢，即存在两个线程A，B，线程A在进入if语句的时候，判断为空，然后完成对象的创建，但是对象的创建也需要一定时间，这个时候线程B也进入if判断，当前线程A还没有创建好，则判断为null，同时也完成对象的创建，这时候线程A，B创建的对象就不是同一个对象了。也就是线程不安全的了，即不满足原子性，可见性，有序性。
在这里插入图片描述

三、懒汉式方案修补方案一

为了保证线程安全，即满足原子性，可见性，有序性。我们首先想到的就是加锁！

由于getInstance方法为static修饰的方式，我们加了synchronized后，锁住的是当前的类，即加的类锁。即多线程操作该类的时候，只有1个线程操作成功！

3.1代码
package singletonModel;public class RLazySingleton {static RLazySingleton instance;private RLazySingleton(){}synchronized public static RLazySingleton getInstance(){if(instance==null){instance=new RLazySingleton();}return instance;}
}
3.2多线程测试代码
package Test;
import singletonModel.RLazySingleton;import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicReference;public class SingletonTest {public static void main(String[] args) {// 使用AtomicReference来存储第一次获取到的LazySingleton实例AtomicReference<RLazySingleton> singletonInstance = new AtomicReference<>();// 我们将启动大量线程来尝试突破单例的线程安全性ExecutorService executorService = Executors.newFixedThreadPool(100);// 用于发现多个实例创建的标志AtomicReference<Boolean> flag = new AtomicReference<>(false);// 提交多个任务到线程池，尝试并发地获取单例实例for (int i = 0; i < 100; i++) {executorService.submit(() -> {RLazySingleton instance = RLazySingleton.getInstance();// 如果原子引用为空，我们设置当前实例if (singletonInstance.get() == null) {singletonInstance.set(instance);} else if (singletonInstance.get() != instance) {// 如果原子引用中的实例与当前获取的实例不同，说明存在多个实例flag.set(true);System.out.println("Detected multiple instances!");}});}executorService.shutdown();// 等待所有任务完成while (!executorService.isTerminated()) {// 等待所有线程执行完毕}if (flag.get().equals(false)) {System.out.println("No multiple instances detected!");}}
}
3.3测试结果

在这里插入图片描述

实验结果证明：这种测试代码也是线程安全的！

3.4存在的问题

通过在getInstance()方法上添加synchronized关键字，可以强制每次只有一个线程能够访问方法，从而避免竞态条件。但这样做会影响性能，因为每次访问都需要进行同步。

四、双重锁检测方案

解决每次访问都需要进行同步的问题。

4.1代码
package singletonModel;
public class DoubleLockSingleton {private static DoubleLockSingleton instance;private DoubleLockSingleton(){}public  static  DoubleLockSingleton getInstance(){if(instance==null){synchronized (DoubleLockSingleton.class){if(instance==null){instance=new DoubleLockSingleton();}}}return instance;}
}
4.2测试代码
package Test;
import singletonModel.DoubleLockSingleton;
import singletonModel.RLazySingleton;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicReference;
public class SingletonTest {public static void main(String[] args) {// 使用AtomicReference来存储第一次获取到的LazySingleton实例AtomicReference<RLazySingleton> singletonInstance = new AtomicReference<>();// 我们将启动大量线程来尝试突破单例的线程安全性ExecutorService executorService = Executors.newFixedThreadPool(100);// 用于发现多个实例创建的标志AtomicReference<Boolean> flag = new AtomicReference<>(false);// 提交多个任务到线程池，尝试并发地获取单例实例for (int i = 0; i < 100; i++) {executorService.submit(() -> {RLazySingleton instance = RLazySingleton.getInstance();// 如果原子引用为空，我们设置当前实例if (singletonInstance.get() == null) {singletonInstance.set(instance);} else if (singletonInstance.get() != instance) {// 如果原子引用中的实例与当前获取的实例不同，说明存在多个实例flag.set(true);System.out.println("Detected multiple instances!");}});}executorService.shutdown();// 等待所有任务完成while (!executorService.isTerminated()) {// 等待所有线程执行完毕}if (flag.get().equals(false)) {System.out.println("No multiple instances detected!");}}
}
测试结果

实验结果也是线程安全的。
在这里插入图片描述

五、其他线程安全的写法

5.1静态内部类
public class StaticInnerClassSingleton {private static class LazyHolder {private static final StaticInnerClass INSTANCE = new StaticInnerClass();}private StaticInnerClass(){}public static StaticInnerClass getInstance(){return LazyHolder.INSTANCE;}
}
5.2枚举类
package singletonModel;public enum EnumSingleton {Instance;public void getInstance(){System.out.println("枚举类创建对象");}
}

六、总结

在Java中，使用枚举（enum）实现的单例模式是唯一能够抵御反射攻击的方式，因为枚举类型没有构造方法（在字节码层面是有私有构造器的，但这是由编译器自己添加的），所以无法通过反射来实例化枚举类型。
枚举攻击！！！：

import java.lang.reflect.Constructor;public class ReflectionSingletonAttack {public static void main(String[] args) {Singleton instanceOne = Singleton.getInstance();Singleton instanceTwo = null;try {// 获取Singleton类的构造函数Constructor[] constructors = Singleton.class.getDeclaredConstructors();for (Constructor constructor : constructors) {// 设置构造函数的访问权限为可访问constructor.setAccessible(true);// 使用构造函数创建一个新的Singleton实例instanceTwo = (Singleton) constructor.newInstance();break;}} catch (Exception e) {e.printStackTrace();}// 打印两个实例的哈希码System.out.println("Instance 1 hash:" + instanceOne.hashCode());System.out.println("Instance 2 hash:" + instanceTwo.hashCode());}
}

枚举类单例模式抵挡枚举攻击

import java.lang.reflect.Constructor;public class EnumReflectionAttack {public static void main(String[] args) {EnumSingleton instanceOne = EnumSingleton.INSTANCE;EnumSingleton instanceTwo = null;try {Constructor[] constructors = EnumSingleton.class.getDeclaredConstructors();for (Constructor constructor : constructors) {constructor.setAccessible(true);instanceTwo = (EnumSingleton) constructor.newInstance();break;}} catch (Exception e) {e.printStackTrace();}System.out.println("Instance 1 hash:" + instanceOne.hashCode());System.out.println("Instance 2 hash:" + (instanceTwo != null ? instanceTwo.hashCode() : "instance creation failed"));}
}

在运行此代码时，您会收到类似以下的异常：

java.lang.IllegalArgumentException: Cannot reflectively create enum objects

因此，使用枚举的方式创建单例是安全的，它有效地防止了反射攻击以及解决了序列化问题。这也是为什么很多推荐使用枚举方式来实现单例模式的原因之一。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/138884.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

安装Elasticsearch步骤（包含遇到的问题及解决方案）

安装Elasticsearch步骤（包含遇到的问题及解决方案）

注&#xff1a;笔者是在centos云服务器环境下安装的Elasticsearch 目录 1.安装前准备 2.下载Elasticsearch 3.启动Elasticsearch 非常容易出问题 第一次运行时&#xff0c;可能出现如下错误&#xff1a; 一、内存不足原因启动失败 二、使用root用户启动问题 三、启动ES自…
阅读更多...
利用QT通过http协议，来实现上传文件功能

利用QT通过http协议，来实现上传文件功能

#假如你有一台服务器&#xff0c;你最想做哪些事&#xff1f;# 大体上的软件界面如下&#xff1a; 主要阐述一哈写的这个软件实现的功能&#xff1a; 通过名称找到指定的文件&#xff0c;并且将文件按照后缀名的格式进行分开&#xff0c;最后再将所有找到的文件&#xff0c;进…
阅读更多...
【4】c++11新特性（稳定性和兼容性）—＞final关键字

【4】c++11新特性（稳定性和兼容性）—＞final关键字

c中增加了final关键字来限制某个类不能被继承&#xff0c;或者某个虚函数不能被重写。如果使用final修饰函数&#xff0c;只能修饰虚函数&#xff0c;并且放在类或者函数的后面。 修饰函数 #include <iostream> using namespace std;class Base { public:virtual void t…
阅读更多...
unity（WebGL） 截图拼接并保存本地，下载PDF

unity（WebGL） 截图拼接并保存本地，下载PDF

截图参考&#xff1a;Unity3D 局部截图、全屏截图、带UI截图三种方法_unity 截图_野区捕龙为宠的博客-CSDN博客 文档下载&#xff1a; Unity WebGL 生成doc保存到本地电脑_unity webgl 保存文件_野区捕龙为宠的博客-CSDN博客 中文输入&#xff1a;Unity WebGL中文输入 支持输…
阅读更多...
Liunx C运算符

Liunx C运算符

一、运算符 &#xff08;一&#xff09;算数运算符 1、float和double不能进行取余操作。 &#xff08;二&#xff09;关系运算符 1、逻辑非 2、逻辑与 例子&#xff1a; if(&#xff08;a-1&#xff09;<b&&b) 如果为真则自增&#xff0c;为假不自增 3、逻辑或 …
阅读更多...
解决spring项目中无法加载resources下文件

解决spring项目中无法加载resources下文件

解决spring项目中无法加载resources下文件 问题发现问题解决步骤一&#xff1a;检查文件名步骤二&#xff1a;确保测试资源目录步骤三&#xff1a;检查文件路径是否正确 问题发现 在学习Spring过程中&#xff0c;TestContext框架试图检测一个默认的XML资源位置。如果您的类被命…
阅读更多...
ExoPlayer架构详解与源码分析（5）——MediaSource

ExoPlayer架构详解与源码分析（5）——MediaSource

系列文章目录 ExoPlayer架构详解与源码分析&#xff08;1&#xff09;——前言 ExoPlayer架构详解与源码分析&#xff08;2&#xff09;——Player ExoPlayer架构详解与源码分析&#xff08;3&#xff09;——Timeline ExoPlayer架构详解与源码分析&#xff08;4&#xff09;—…
阅读更多...
图扑智慧仓储数据可视化监控平台

图扑智慧仓储数据可视化监控平台

随着市场竞争加剧和市场需求的不断提高&#xff0c;企业亟需更加高效、智能且可靠的仓储物流管理方式&#xff0c;以提升企业的物流效率&#xff0c;减少其输出成本&#xff0c;有效应对市场上的变化和挑战。 图扑软件应用自研 HT for Web 产品搭建的 2D 智慧仓储可视化平台&a…
阅读更多...
adb调试Linux嵌入式设备记录

adb调试Linux嵌入式设备记录

1. ADB的全称为Android Debug Bridge&#xff0c;调试设备或调试开发的Android APP。 2.adb的windows下载安装路径&#xff1a;SDK 平台工具版本说明 | Android 开发者 | Android Developers 3.linux中安装adb,参考该链接&#xff1a; https://www.cnblogs.com/androidsu…
阅读更多...
【兔子王赠书第2期】《案例学Python（基础篇）》

【兔子王赠书第2期】《案例学Python（基础篇）》

文章目录 前言推荐图书本书特色本书目录本书样章本书读者对象粉丝福利丨评论免费赠书尾声 前言 随着人工智能和大数据的蓬勃发展&#xff0c;Python将会得到越来越多开发者的喜爱和应用。身边有很多朋友都开始使用Python语言进行开发。正是因为Python是一门如此受欢迎的编程语…
阅读更多...
Segment Anything（论文解析）

Segment Anything（论文解析）

Segment Anything 摘要1.介绍2 SAM任务SAM模型 摘要 我们介绍了“Segment Anything” (SA) 项目&#xff1a;这是一个新的任务、模型和数据集对于图像分割。使用我们高效的模型进行数据收集&#xff0c;我们构建了迄今为止最大的分割数据集&#xff08;远远超过其他数据集&…
阅读更多...
网络解析（二）

网络解析（二）

ICMP 报文有很多的类型，不同的类型有不同的代码。最常用的类型是主动请求为 8，主动请求的应答为 0。 ICMP 相当于网络世界的侦察兵。我讲了两种类型的 ICMP 报文，一种是主动探查的查询报文，一种异常报告的差错报文； ping 使用查询报文，Traceroute 使用差错报文。 IP和…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023