单例模式（饿汉式单例、懒汉式单例、DCL模式、静态内部类实现、枚举实现）看这一篇就够了！

最新推荐文章于 2022-04-12 22:43:28 发布
最新推荐文章于 2022-04-12 22:43:28 发布
阅读量1.7w 收藏 1
点赞数 2
文章标签： java 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxy_zxl/article/details/116658589
版权

single(二十一种设计模式之一）

1.单例模式要素

	确保一个类中只有一个实例，并提供一个全局访问点
	a.私有构造方法 
    b.私有静态引用指向自己实例 
    c.以自己实例为返回值的公有静态方法

2.饿汉式单例

public class Hungry {
	//私有的构造函数，保证外类不能实例化本类
	private Hungry (){}
	//自己创建一个类的实例化
	private final static Hungry HUNGRY= new Hungry ();
	//创建一个get方法，返回一个实例HUNGRY
	public static Hungry getInstance(){
		return HUNGRY;
	}
}

2.1饿汉式单例特点

  1. 饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

  2. 从线程安全性上讲，饿汉式是线程安全的，因为虚拟机保证只会装载一次，在装载类的时候是不会发生并发的。

3.懒汉式单例

public class LazyMan{
	private LazyMan(){
	}
	private static LazyMan lazyMan;
	public static LazyMan getInstance(){
		if(lazyMan==null){
			lazyMan=new LazyMan();
		}
		return lazyMan;
	}
}

不难发现在多线程并发时懒汉式单例并不安全，于是出现

4.懒汉式单例双重检测锁（DCL模式）

	public class LazyMan{
	private LazyMan(){
	}
	private static LazyMan lazyMan;
	//双重检测锁
	public static LazyMan getInstance(){
		if(lazyMan==null){
			synchronized (LazyMan.class){
					if(lazyMan==null){
						lazyMan=new LazyMan();
					}
			}
		}
		return lazyMan;
	}
}

在lazyMan为空时在LazyMan这个类上增加锁，保证这个类只有一个，但有可能在并发极端情况下是会出现问题的

//双重检测锁
	public static LazyMan getInstance(){
		if(lazyMan==null){
			synchronized (LazyMan.class){
					if(lazyMan==null){
						lazyMan=new LazyMan(); //不是原子性的操作
						/**
								1.分配内存空间
							    2.执行构造方法，初始化对象
							    3.把这个对象指向这个空间

							我们期望jvm上是执行123的顺序，
							但在这里会出现指令重排的现象，
							jvm执行顺序为132
							假设有a线程，执行顺序为1,2,3，
							当执行到2时，b线程开始执行顺序为
							1,3,2这时在判断lazyMan时结果不为空
							于是执行返回操作但这是的lazyMan对象
							是有问题的
						*/
					}
			}
		}
		return lazyMan;
	}

为了避免产生指令重排，增加volatile

public class LazyMan{
	private LazyMan(){
	}
	private volatile static LazyMan lazyMan;
	//双重检测锁
	public static LazyMan getInstance(){
		if(lazyMan==null){
			synchronized (LazyMan.class){
					if(lazyMan==null){
						lazyMan=new LazyMan();
					}
			}
		}
		return lazyMan;
	}
}

5.懒汉式单例(静态内部类实现）

public class Holder{
	private Holder(){
	
	}
	public static Holder getInstace(){
		return InnerClass.HOLDER;
	}
	public static class InnerClass{
		private static final Holder HOLDER = new Holder();
	}
}

但以上这些懒汉式其实都是不安全的，因为反射可以破坏单例模式

public class LazyMan{
	private LazyMan(){
	}
	private volatile static LazyMan lazyMan;
	//双重检测锁
	public static LazyMan getInstance(){
		if(lazyMan==null){
			synchronized (LazyMan.class){
					if(lazyMan==null){
						lazyMan=new LazyMan();
					}
			}
		}
		return lazyMan;
	}
	//反射
	public static void main (String[] args){
		LazyMan instance1=LazyMan.getInstance();
		Constructor<LazyMan> declaredConstructor=LazyMan.class.getDeclaredConstructor(null)
		//破坏构造器私有化
		declaredConstructor.setAccessible(true);
		LazyMan instance2 =declaredConstructor.newInstance();
		//打印的值并不相同，说明单例已被破坏
		System.out.println(instance1);
		System.out.println(instance2);
}

当然这种也有解决的方法

public class LazyMan{
	private LazyMan(){
		synchronized(LazyMan.class){
			if(lazyMan!=null){
				throw new RuntimeException("请不要使用反射破坏单例异常"）
	}
	private volatile static LazyMan lazyMan;
	//双重检测锁
	public static LazyMan getInstance(){
		if(lazyMan==null){
			synchronized (LazyMan.class){
					if(lazyMan==null){
						lazyMan=new LazyMan();
					}
			}
		}
		return lazyMan;
	}
	//反射
	public static void main (String[] args){
		LazyMan instance1=LazyMan.getInstance();
		Constructor<LazyMan> declaredConstructor=LazyMan.class.getDeclaredConstructor(null)
		//破坏构造器私有化
		declaredConstructor.setAccessible(true);
		LazyMan instance2 =declaredConstructor.newInstance();
		//打印时报错
		System.out.println(instance1);
		System.out.println(instance2);
}

这时再次执行main方法时会报错运行时异常
如果将两个instance对象都直接new出来

public class LazyMan{
	private LazyMan(){
		synchronized(LazyMan.class){
			if(lazyMan!=null){
				throw new RuntimeException("请不要使用反射破坏单例异常"）
	}
	private volatile static LazyMan lazyMan;
	//双重检测锁
	public static LazyMan getInstance(){
		if(lazyMan==null){
			synchronized (LazyMan.class){
					if(lazyMan==null){
						lazyMan=new LazyMan();
					}
			}
		}
		return lazyMan;
	}
	//反射
	public static void main (String[] args){
		//LazyMan instance1=LazyMan.getInstance();
		Constructor<LazyMan> declaredConstructor=LazyMan.class.getDeclaredConstructor(null)
		//破坏构造器私有化
		declaredConstructor.setAccessible(true);
		LazyMan instance1 =declaredConstructor.newInstance();
		LazyMan instance2 =declaredConstructor.newInstance();
		//打印时打印不同的地址-->单例再次被破坏
		System.out.println(instance1);
		System.out.println(instance2);
}

我们发现单例依然可以被破坏
此时我们再次进行升级定义一个假设其他人都不知道的变量

public class LazyMan{
	//定义参数，也可以说密钥
	private static boolean flag=false;
	private LazyMan(){
		synchronized(LazyMan.class){
			if(flag==fasle){
				flag=true;
			}else{
				throw new RuntimeException("请不要使用反射破坏单例异常"）
			}
		}
	private volatile static LazyMan lazyMan;
	//双重检测锁
	public static LazyMan getInstance(){
		if(lazyMan==null){
			synchronized (LazyMan.class){
					if(lazyMan==null){
						lazyMan=new LazyMan();
					}
			}
		}
		return lazyMan;
	}
	//反射
	public static void main (String[] args){
		//LazyMan instance1=LazyMan.getInstance();
		Constructor<LazyMan> declaredConstructor=LazyMan.class.getDeclaredConstructor(null)
		//破坏构造器私有化
		declaredConstructor.setAccessible(true);
		LazyMan instance1 =declaredConstructor.newInstance();
		LazyMan instance2 =declaredConstructor.newInstance();
		//打印时抛出异常
		System.out.println(instance1);
		System.out.println(instance2);
}

这时我们发现好像单例不会被破坏了，但是如果有人破解了flag字段，使得flag字段私有化失效

public class LazyMan{
	//定义参数，也可以说密钥
	private static boolean flag=false;
	private LazyMan(){
		synchronized(LazyMan.class){
			if(flag==fasle){
				flag=true;
			}else{
				throw new RuntimeException("请不要使用反射破坏单例异常"）
			}
		}
	private volatile static LazyMan lazyMan;
	//双重检测锁
	public static LazyMan getInstance(){
		if(lazyMan==null){
			synchronized (LazyMan.class){
					if(lazyMan==null){
						lazyMan=new LazyMan();
					}
			}
		}
		return lazyMan;
	}
	//反射
	public static void main (String[] args){
		//LazyMan instance1=LazyMan.getInstance();
		Field flag =LazyMan.class.getDeclaredField("flag")
		//使得私有化参数失效
		flag.setAccessible(true);
		Constructor<LazyMan> declaredConstructor=LazyMan.class.getDeclaredConstructor(null)
		//破坏构造器私有化
		declaredConstructor.setAccessible(true);
		LazyMan instance1 =declaredConstructor.newInstance();
		//更改flag值为false
		flag.set(instance1,false);
		LazyMan instance2 =declaredConstructor.newInstance();
		//打印时抛出异常
		System.out.println(instance1);
		System.out.println(instance2);
}

破解了flag字段后我们发现单例依然可以被破坏
这时候就出现了枚举类单例模式

6.懒汉式单例(枚举实现）

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);
}

这时我们再次通过反射去破坏单例

public enum EnumSingle{
	INSTANCE;
	public EnumSingle getInstance(){
		return INSTANCE;
	}
	class Test{
		public static void main (String[] args) throws Exception{
			EnumSingle instance1 =EnumSingle.INSTANCE;
			Constructor<EnumSingle> declaredConstructor=EnumSingle.class.getDeclaredConstructor(null)		
			declaredConstructor.setAccessible(true);
			EnumSingle instance2=declaredConstructor.new   Instance()
			//报错枚举类中没有空参的构造方法
			System.out.println(instance1);
			System.out.println(instance2);
}

通过jad工具反编译
发现构造器为有参构造参数为（String s，int i）

public enum EnumSingle{
	INSTANCE;
	public EnumSingle getInstance(){
		return INSTANCE;
	}
	class Test{
		public static void main (String[] args) throws Exception{
			EnumSingle instance1 =EnumSingle.INSTANCE;
			Constructor<EnumSingle> declaredConstructor=EnumSingle.class.getDeclaredConstructor(String.class,int.class)		
			declaredConstructor.setAccessible(true);
			EnumSingle instance2=declaredConstructor.new   Instance()
			//报错不能用反射破坏单例
			System.out.println(instance1);
			System.out.println(instance2);
}
cxy_zxl
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
Java实现单例模式之饿汉式、懒汉式、枚举式
09-01
本篇文章主要介绍了Java实现单例的3种普遍的模式，饿汉式、懒汉式、枚举式。具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
单例模式（饿汉式，DCL懒汉式）
Lin_XXiang的博客
11-14 938
1、饿汉式 2、懒汉式，DCL懒汉式 3、单例不安全（枚举解决）
开发中实战单例的使用：静态内部类实现懒汉式单例
m0_50802926的博客
04-12 398
单例的精华在于：static，代表着共享，final，代表不可变 在内部类被加载和初始化时，才创建INSTANCE实例对象。 静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化的。 因为是在内部类加载和初始化时，创建的，因此是线程安全的。 public class Singleton { // 私有化构造方法 private Singleton(){} // 静态内部类 private static class Inner{ p...
四种方式实现单例设计模式，饿汉式、懒汉式、静态内部类方法、枚举方法
ErwinLiu的CSDN
09-01 330
是什么 单例模式保证了一个类只有一个实例，并且提供一个访问该实例的全局访问点 常见的应用场景有 Windows的Task Manager（任务管理器）就是典型的单例模式，你可以唤起任务管理器之后再次打开它，会发现它始终只存在一个 Windows的回收站 网站的计数器应用单例模式，否则难以实现同步 应用程序的日志，因为共享的日志一般一直处于打开状态，如果不以单例模式进行设计难以完成同步追加 数据库的连接池，没有必要实现多个连接池 在Spring中，每个Bean也是单例的，这样做的优点是Spring容器可以管
反射——懒汉单例模式（解决多线程下也能保持单例模式）
Ark方舟
04-29 317
懒汉单例模式 import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Member; class Singleton { private static Singleton singleton; private Singleton() { //构造方法私有化 Sys...
CGB2108-Day19-反射-反射的方法
QQQiu_123的博客
11-01 115
反射的概念 反射是Java这门语言中比较有特点的一个特征，反射非常强大，我们可以通过反射获取目标类当中的资源，甚至是私有资源 反射就像一面镜子，它可以在运行时获取一个类的所有信息，可以获取到任何定义的信息（包括成员变量，成员方法，构造器等），并且可以操纵类的字段、方法、构造器等部分。 反射的方法 反射需要用到的API 获取字节码对象 Class.forName(“类的全路径”); 注意：传入的是类的全路径名，包含包名.类名，而且会抛出异常 类名.class 注意：这个写法需要自己手动接一
java 单例模式（懒汉式与饿汉式）
08-29
主要介绍了java 单例模式的相关资料,这里对懒汉式与饿汉式都做了实例介绍，需要的朋友可以参考下
一个单例模式的晋级过程(饿汉-懒汉-DCL-IoDH-枚举)
12-21
一个单例模式的晋级过程(饿汉-懒汉-DCL-IoDH-枚举) 文章目录一个单例模式的晋级过程(饿汉-懒汉-DCL-IoDH-枚举)什么是单例？单例有哪些运用场景？实现1.饿汉式测试优化-final2.懒汉式优化-加锁同步3.DCL双检锁/双重...
老生常谈C++的单例模式与线程安全单例模式(懒汉/饿汉)
08-31
下面小编就为大家带来一篇老生常谈C++的单例模式与线程安全单例模式(懒汉/饿汉)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
单例模式（饿汉模式、懒汉模式、DCL单例模式、枚举）
10-01
饿汉模式、懒汉模式、DCL单例模式、枚举；不同情况下使用不同的单例创建模式
重学Java之单例模式--DCL懒汉式
weixin_44021334的博客
03-16 757
接前篇 重学Java之单例模式–懒汉式_南国樗里疾的博客-CSDN博客 https://blog.csdn.net/weixin_44021334/article/details/114880800 ， 说到懒汉式多线程不安全， 改进办法是 双重锁模式，也就是 双重锁定(Double-Check Locking) ，简称 DCL 。 1.简单加锁 对外提供获取实例的方法加上锁， package single; import java.lang.reflect.Constructor; import jav
设计模式之---单例模式（以及DCL懒汉式并发问题解决）
γìńɡ雄尐年ぐ的博客
11-18 695
最简单的设计模式之一 单例模式主要用途：保证一个类只能有一个实例，并且在全局提供一个访问点。 常用实现方式：懒汉式、饿汉式、静态内部类式、枚举式 为什么需要单例模式？ 假如此时你想读取一个XML配置文件，且该配置会被多次引用，那在每次引用时，就需要实例化一个Java Bean，但实际上我们全程只需要实例化一次，多处调用即可，当配置文件越来越多时，实例的创建占用系统资源是不可忽视的。那么此时...
单例模式的懒汉模式为什么在高并发中会出现问题？一个代码例子告诉你
小王博客基地
11-05 571
一、前言 我们对于单例模式我觉得是23种设计模式中大家最熟悉的一个，但是我们真的理解清楚了吗？小编最近才想到都说懒汉模式不合适出现在高并发中，会出现并发问题，于是小编研究了一下才发现，今天就带大家用一个例子来证明是不是高并发会出现错误！！ 二、懒汉模式优缺点 - 优点： 懒汉式相对于饿汉式的优势是支持延迟加载 - 缺定： 懒汉式有性能问题，不支持高并发 三、案例分析 - 手机数量类： import lombok.Data; @Data public class Phone { //手机余量
[23]单例模式懒汉式并发安全问题
斌binnid
10-30 322
 一、饿汉式 /*饿汉式*/ class SingleTon{ private SingleTon single=new Single(); public SingleTon getInstance(){ return s; } }  饿汉式的是共同对象，但是因为没有多次运算。所以不会多线程时，不会产生数据出错。 二、懒汉式 class Sing...
单例模式（饿汉式，懒汉式，反射破坏，枚举）
Tiko的博客
04-18 907
文章目录单例模式饿汉式懒汉式方式一方式二 DCL（double check lock）+volatile关键字volatile可以保证可见性，但不能保证原子性。可以避免指令重排现象的产生。以上就安全了吗？不，反射可以破坏！解决方案，再在getInstance中加一把锁，来解决以上反射的破坏方案解决了，就安全了吗？不，如果一开始不通过getInstance创建，就又不安全了。解决办法，非当前的对象-...
反射与单例模式：懒汉式的逆袭？
Lzw_Fight的博客
05-21 220
如果程序中仅仅只是需要实例化某个对象一次，但是有需要在不同的地方上使用该实例化的对象，这时就可以用单例模式。可以避免在不同的类中多次使用new来创建该对象，从而造成多个对象堆积在内存中。单例模式分为懒汉式和饿汉式。 饿汉和懒汉的对比 1.饿汉是在进程调用前已经创建好了实例化对象，而懒汉式是什么时候调用就什么时候创建 2.饿汉是线程安全，而懒汉式是线程不安全的，如果让懒汉式线程安全的话就需要加上同步锁【本次重点】 3.效率方面，由于饿汉式并不会加上同步锁，所以执行效率上饿汉式会更胜一筹 4.内存方面，由于饿汉
单例模式总结 饿汉式 懒汉式 静态内部类 枚举 反射破坏单例 序列化 附代码
qq_31617121的博客
06-25 535
饿汉式 懒汉式单例模式参考博客 单例模式 饿汉式和懒汉式 静态内部类实现单例模式参考博客 静态内部类 单例设计模式举例 不管是饿汉式，还是懒汉式中的线程安全的双重检测机制和静态内部类实现单例模式，都会被反射破坏单例模式。利用反射得到私有构造方法，还是可以生成多个具体类，代码如下 package com.company.反射与内省.单例设计模式改进; import java.io.Se...
懒汉式单例模式如何防止发射和反序列化漏洞
qq_39572257的博客
06-03 446
懒汉式单例模式： /** * 测试饿汉式单例模式 * Created by GQ on 2019/4/17. */ public class Demo02 implements Serializable{ //类初始化时，不初始化这个对象（延时加载，真正使用的时候在创建） private static Demo02 demo02; private Demo02() ...
单例模式实现方式包括饿汉式和懒汉式区别
最新发布
03-27
饿汉式和懒汉式是单例模式的两种实现方式： 1. 饿汉式：在类加载时就创建了对象实例。这种方式的优点是线程安全，简单易用，缺点是会浪费一定的内存空间。 2. 懒汉式：在第一次使用时才创建对象实例。这种方式的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值