单例模式

于 2021-01-23 17:01:48 发布
阅读量173 收藏
点赞数
分类专栏： JUC并发编程 23种设计模式 文章标签： 反编译 反射 java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jj89929665/article/details/113055008
版权
本文探讨了单例模式的实现方式，包括饿汉式、懒汉式，以及如何通过反射破坏。重点介绍了使用枚举创建的单例模式，解释其如何防止反射攻击，并展示了实际的反编译案例。最后总结了单例模式的安全性和保护措施的重要性。
摘要由CSDN通过智能技术生成

单例模式


饿汉式 DCL懒汉式

1.饿汉式

package JUC;

/**
 * 饿汉式 浪费内存
 */
public class SingletonHungry {
	
	private byte[] data1 = new byte[1024*1024];
	private byte[] data2 = new byte[1024*1024];
	private byte[] data3 = new byte[1024*1024];
	private byte[] data4 = new byte[1024*1024];

	private SingletonHungry() {
		System.out.println(Thread.currentThread().getName());
	}
	
	private final static SingletonHungry HUNGRY = new SingletonHungry();
	
	public static SingletonHungry getInstance() {
		return HUNGRY;
	};
	
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			new Thread(()->{
				SingletonHungry.getInstance();
			}).start();
		}
	}
}

2.懒汉式

package JUC;
/**   
 * 懒汉式单例 双重检测锁+volatile防止指令重排 
 */
public class SingletonLazyMan {

	private SingletonLazyMan(){
		System.out.println(Thread.currentThread().getName());
	}
	
	private volatile static SingletonLazyMan lazyMan; 
	
	//双重检测锁 DCL懒汉式
	public static SingletonLazyMan getInstance() {
		if (lazyMan==null) {
			synchronized (SingletonLazyMan.class) {
				if (lazyMan==null) {
					lazyMan = new SingletonLazyMan();
					/**
					 * 不是原子性操作
					 * 1.分配内存空间
					 * 2.执行构造方法，初始化对象
					 * 3.把对象指向这个空间
					 * 
					 * 指令重排 123  
					 * 但是如果执行132 A
					 * 				B
					 */
				}
			}
		}
		return lazyMan; //此时SingletonLazyMan还没有完成构造
	}
	
	public static void main(String[] args) {
		for (int i = 0; i < 10; i++) {
			new Thread(()->{
				SingletonLazyMan.getInstance();
			}).start();
		}
	}
}

2.1反射破坏单例

package JUC;

import java.lang.reflect.Constructor;

/**   
 * 懒汉式单例 双重检测锁+volatile防止指令重排 
 */
public class SingletonLazyMan {

	private SingletonLazyMan(){
		System.out.println(Thread.currentThread().getName());
	}
	
	private volatile static SingletonLazyMan lazyMan; 
	
	//双重检测锁 DCL懒汉式
	public static SingletonLazyMan getInstance() {
		if (lazyMan==null) {
			synchronized (SingletonLazyMan.class) {
				if (lazyMan==null) {
					lazyMan = new SingletonLazyMan();
					/**
					 * 不是原子性操作
					 * 1.分配内存空间
					 * 2.执行构造方法，初始化对象
					 * 3.把对象指向这个空间
					 * 
					 * 指令重排 123  
					 * 但是如果执行132 A
					 * 				B
					 */
				}
			}
		}
		return lazyMan; //此时SingletonLazyMan还没有完成构造
	}
	
	public static void main(String[] args) throws Exception, SecurityException {
		SingletonLazyMan lazyMan = SingletonLazyMan.getInstance();
		Constructor<SingletonLazyMan> constructor = SingletonLazyMan.class.getDeclaredConstructor();
		constructor.setAccessible(true);
		SingletonLazyMan lazyMan2 = constructor.newInstance();
		
		if (lazyMan == lazyMan2) {
			System.out.println("相等");
		}else {
			System.out.println("不相等");
		}
	}
}

在这里插入图片描述

2.2改良懒汉式单例 （三重检测）

package JUC;

import java.lang.reflect.Constructor;

/**   
 * 懒汉式单例 三重检测锁+volatile防止指令重排 
 */
public class SingletonLazyMan {

	private SingletonLazyMan(){
		//三重检测
		synchronized (SingletonLazyMan.class) {
			if (lazyMan!=null) {
				throw new RuntimeException("不要试图使用反射破坏异常");
			}
		}
		System.out.println(Thread.currentThread().getName());
	}
	
	private volatile static SingletonLazyMan lazyMan; 
	
	//双重检测锁 DCL懒汉式
	public static SingletonLazyMan getInstance() {
		if (lazyMan==null) {
			synchronized (SingletonLazyMan.class) {
				if (lazyMan==null) {
					lazyMan = new SingletonLazyMan();
					/**
					 * 不是原子性操作
					 * 1.分配内存空间
					 * 2.执行构造方法，初始化对象
					 * 3.把对象指向这个空间
					 * 
					 * 指令重排 123  
					 * 但是如果执行132 A
					 * 				B
					 */
				}
			}
		}
		return lazyMan; //此时SingletonLazyMan还没有完成构造
	}
	
	public static void main(String[] args) throws Exception, SecurityException {
		//SingletonLazyMan lazyMan = SingletonLazyMan.getInstance();
		Constructor<SingletonLazyMan> constructor = SingletonLazyMan.class.getDeclaredConstructor();
		constructor.setAccessible(true);
		SingletonLazyMan lazyMan2 = constructor.newInstance();
		SingletonLazyMan lazyMan3 = constructor.newInstance();
		
		if (lazyMan == lazyMan2) {
			System.out.println("相等");
		}else {
			System.out.println("不相等");
		}
	}
}

在这里插入图片描述

2.3改良单例信号灯法

package JUC;

import java.lang.reflect.Constructor;

/**   
 * 懒汉式单例 三重检测锁+volatile防止指令重排 
 */
public class SingletonLazyMan {

	//信号灯
	private static boolean gouzi = false;
	
	private SingletonLazyMan(){
		//三重检测
		synchronized (SingletonLazyMan.class) {
			if (gouzi==false) {
				gouzi = true;
			} else {
				throw new RuntimeException("不要试图使用反射破坏异常");
			}
		}
		System.out.println(Thread.currentThread().getName());
	}
	
	private volatile static SingletonLazyMan lazyMan; 
	
	//双重检测锁 DCL懒汉式
	public static SingletonLazyMan getInstance() {
		if (lazyMan==null) {
			synchronized (SingletonLazyMan.class) {
				if (lazyMan==null) {
					lazyMan = new SingletonLazyMan();
					/**
					 * 不是原子性操作
					 * 1.分配内存空间
					 * 2.执行构造方法，初始化对象
					 * 3.把对象指向这个空间
					 * 
					 * 指令重排 123  
					 * 但是如果执行132 A
					 * 				B
					 */
				}
			}
		}
		return lazyMan; //此时SingletonLazyMan还没有完成构造
	}
	
	public static void main(String[] args) throws Exception, SecurityException {
		//SingletonLazyMan lazyMan = SingletonLazyMan.getInstance();
		Constructor<SingletonLazyMan> constructor = SingletonLazyMan.class.getDeclaredConstructor();
		constructor.setAccessible(true);
		SingletonLazyMan lazyMan2 = constructor.newInstance();
		SingletonLazyMan lazyMan3 = constructor.newInstance();
		
		if (lazyMan == lazyMan2) {
			System.out.println("相等");
		}else {
			System.out.println("不相等");
		}
	}
}

在这里插入图片描述

2.4破坏单例信号灯

package JUC;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/**   
 * 懒汉式单例 三重检测锁+volatile防止指令重排 
 */
public class SingletonLazyMan {

	//信号灯
	private static boolean gouzi = false;
	
	private SingletonLazyMan(){
		//三重检测
		synchronized (SingletonLazyMan.class) {
			if (gouzi==false) {
				gouzi = true;
			} else {
				throw new RuntimeException("不要试图使用反射破坏异常");
			}
		}
		System.out.println(Thread.currentThread().getName());
	}
	
	private volatile static SingletonLazyMan lazyMan; 
	
	//双重检测锁 DCL懒汉式
	public static SingletonLazyMan getInstance() {
		if (lazyMan==null) {
			synchronized (SingletonLazyMan.class) {
				if (lazyMan==null) {
					lazyMan = new SingletonLazyMan();
					/**
					 * 不是原子性操作
					 * 1.分配内存空间
					 * 2.执行构造方法，初始化对象
					 * 3.把对象指向这个空间
					 * 
					 * 指令重排 123  
					 * 但是如果执行132 A
					 * 				B
					 */
				}
			}
		}
		return lazyMan; //此时SingletonLazyMan还没有完成构造
	}
	
	public static void main(String[] args) throws Exception, SecurityException {
		//获取属性 改为private允许访问
		Field[] fields = SingletonLazyMan.class.getDeclaredFields();
		for (Field field : fields) {
			System.out.println(field.getName());
			field.setAccessible(true);
		}
		Field field = SingletonLazyMan.class.getDeclaredField("gouzi");
		
		//SingletonLazyMan lazyMan = SingletonLazyMan.getInstance();
		Constructor<SingletonLazyMan> constructor = SingletonLazyMan.class.getDeclaredConstructor();
		constructor.setAccessible(true);
		SingletonLazyMan lazyMan2 = constructor.newInstance();

		//修改属性
		field.set(lazyMan2, false);
		
		SingletonLazyMan lazyMan3 = constructor.newInstance();
		
		if (lazyMan3 == lazyMan2) {
			System.out.println("相等");
		}else {
			System.out.println("不相等");
		}
	}
}

在这里插入图片描述

3.使用枚举 保护单例模式（防止反射攻击）

3.1为什么枚举可以保护 单例模式？

在这里插入图片描述

在这里插入图片描述

3.2 枚举创建单例

package JUC;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**   
 * 枚举懒汉式单例
 */
public enum EnumSingletonLazyMan {

	INSTANCE;
	
	public EnumSingletonLazyMan getInstance() {
		return INSTANCE;
	}
}

class TTTT{
	
	public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		EnumSingletonLazyMan e1 = EnumSingletonLazyMan.INSTANCE;
		
		Constructor<EnumSingletonLazyMan> constructor = EnumSingletonLazyMan.class.getDeclaredConstructor();
		constructor.setAccessible(true);
		
		//in thread "main" java.lang.NoSuchMethodException: JUC.EnumSingletonLazyMan.<init>()
		EnumSingletonLazyMan e2 = constructor.newInstance();
		
		if (e1 == e2) {
			System.out.println("相等");
		}else {
			System.out.println("不相等");
		}
	}
}

而得到的是这个
在这里插入图片描述
并非
在这里插入图片描述

3.3查看底层 反编译

找到.class目录下
在这里插入图片描述
进行反编译
在这里插入图片描述
也是有空参的，

3.4 使用jad.exe

在这里插入图片描述
在这里插入图片描述
看到最终源码 这里是有参构造器。

再次修改代码
在这里插入图片描述

4.总结

单例不安全，无论怎么修改都能被反射破解。
枚举创建单例安全，可以通过 专业编译器反编译出来，（枚举类）真实的源码。

一只小小狗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
（一）单例模式详解
Java's paradise
06-02 8400
作者：zuoxiaolong8810（左潇龙），转载请注明出处。             上一章，我们学习了设计模式的概念，以及为什么要学习设计模式，还有在进行系统设计时应当遵守的六大原则，本章我们就来开始一一的学习GOF当中的二十三钟设计模式。             我一会在思考如何去诠释这么多设计模式，因为网上有很多现成的，可供学习的资料，我在想有什么地方可以让各位跟着我的节奏去学习，而
单例、单例模式
03-20 271
简单的实现一个单例： + (instancetype)sharedInstance {           static MyClass *_instance = nil;           static dispatch_once_t predicate;           dispatch_once(&predicate, ^{                   _in
一 单例模式
Ankas
09-11 1161
吹前序 什么是设计模式 单例模式 使用场景 定义 共同构成 实现的类型 饿汉式 静态内部类 懒加载 总结 优点 缺点吹前序作为一名程序员，想要看出与别人的差距，除了必备吹水技能，斗图技能，那就还剩最重要的一点——代码能力了！那么如何才能在众多段子手，老司机中通过自己的代码成功装逼呢，作为程序员的你，必须要了解，学习，使用的杀手锏来了 设计模式什么是设计模式你可以这样理解它： 程序的设计模式通常来说
设计模式-单例模式 C++实现
不很正派的专栏
08-18 331
对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务；一个系统只能有一个窗口管理器或文件系统；一个系统只能有一个计时工具或ID（序号）生成器。如何保证一个类只有一个实例并且这个实例易于被访问呢？定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实
43丨单例模式（下）：如何设计实现一个集群环境下的分布式单例模式？1
08-03
单例模式是一种设计模式，旨在确保一个类只有一个实例，并提供全局访问点。在单例模式中，类的构造函数是私有的，防止外部直接创建对象，而是通过静态方法获取该类的唯一实例。单例模式的唯一性通常是在进程范围内，...
浅谈Spring单例Bean与单例模式的区别
08-28
"浅谈Spring单例Bean与单例模式的区别" 本文主要介绍了Spring单例Bean与单例模式的区别，通过对比两者的定义、实现机制和应用场景，帮助读者更好地理解这两种概念的异同。 一、单例模式的定义和实现 单例模式是一...
JS 设计模式之：单例模式定义与实现方法浅析
11-21
本文实例讲述了JS 设计模式之：单例模式定义与实现方法。分享给大家供大家参考，具体如下： 良好的设计模式可以显著提高代码的可读性，降低复杂度和维护成本。笔者打算通过几篇文章通俗地讲一讲常见的或者实用的设计...
使用单例模式创建学生管理系统（饿汉式、懒汉式）
04-28
单例模式是软件设计模式中的一种，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。在Java或类似的面向对象编程语言中，单例模式常用于管理共享资源，如数据库连接池、线程池或者配置文件等。在这个...
.Net 单例模式(Singleton)
01-02
 单例模式 Singleton Pattern 问题解决： （1）单例模式简介： Singleton模式要求一个类有且仅有一个实例，并且提供了一个全局的访问点。这就提出了一个问题：如何绕过常规的构造器，提供一种机制来保证一个类只有...
Design Pattem 详解--单例模式
chuli0327的博客
10-15 320
单例设计模式 1.概念： 所谓类的单例设计模式，就是采用一定的方法保证在整个的软件系统中，对某个类，只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法） eg：Hibranate 的 SessionFactory 她充当数据存储源的代理并负责创建Session对象，SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个SessionFactory就够，这是就会使用到单例模式 2.八种单例模式： ...
设计模式——单例模式
qq_37776015的博客
04-29 467
单例模式的定义与特点 单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。 在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用...
单例模式与工厂模式解析
"单例模式与工厂模式是两种常见的设计模式，在软件开发中有着广泛的应用。单例模式确保一个类只有一个实例，而工厂模式则允许子类决定实例化哪个类。这两种模式各有特点，适用于不同的场景。" 1. **单例模式**： ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一只小小狗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值