Java设计模式-单例模式

最新推荐文章于 2024-05-20 23:45:16 发布
最新推荐文章于 2024-05-20 23:45:16 发布
阅读量90 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24552437/article/details/103946273
版权

一、饿汉式

1、静态常量

package singleton.type1;

public class TestSingleton01 {
	public static void main(String[] args) {
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance1 == instance2);
		System.out.println("instance1.hashCode = " + instance1.hashCode());
		System.out.println("instance2.hashCode = " + instance2.hashCode());
	}
}

class Singleton {
	//1.构造器私有化,不能通过new创建实例
	private Singleton(){
	}
	
	//2.类加载时就初始化实例
	private static final Singleton INSTANCE = new Singleton();
	
	//3.提供获取实例的静态方法
	public static Singleton getInstance(){
		return INSTANCE;
	}
}

2、静态代码块

package singleton.type2;

public class TestSingleton02 {
	public static void main(String[] args) {
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		System.out.println(instance1 == instance2);
		System.out.println("instance1.hashCode = " + instance1.hashCode());
		System.out.println("instance2.hashCode = " + instance2.hashCode());
	}
}

class Singleton {
	
	//1.构造器私有化
	private Singleton(){
	}
	
	//2.静态实例对象
	private static Singleton instance;
	
	//3.通过静态代码块实例化对象
	static {
		instance = new Singleton();
	}
	
	//4.提供静态的获取实例的方法
	public static Singleton getInstance(){
		return instance;
	}
}
结论：饿汉式虽然实现了单例，不存在线程安全问题，但因为在类加载时就创建了实例，如果在后续代码中没有使用到这个实例，可能造成内存浪费。

二、懒汉式

1、懒汉式写法1（存在线程安全问题）

package singleton.type3;

public class TestSingleton03 {
	public static void main(String[] args) {
		//模拟多线程下线程不安全问题
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};
			
		}.start();
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};
			
		}.start();
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};
			
		}.start();
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};
			
		}.start();
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};
			
		}.start();
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};
			
		}.start();
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};
			
		}.start();
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};
			
		}.start();
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};
			
		}.start();
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};
			
		}.start();
	}
}

class Singleton {
	
	//1.构造器私有化
	private Singleton(){
	}
	
	//2.静态实例对象
	private static Singleton instance;
	
	//3.在调用时实例化对象
	public static Singleton getInstance(){
		if(instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
}

执行n次后出现线程安全问题
在这里插入图片描述

说明：
1）起到了Lazy Loading的效果，但是只能在单线程下使用。
2）在多线程下使用，会有线程安全问题。
3）线程安全问题如下：

当线程A进行if(instance==null)，判断为null进入if后还没有实例化对象，此时线程B也进行了if(instance==null)，判断null进入if，结果线程A和线程B创建了两个不同的实例。
在这里插入图片描述

结论：实际开发中不推荐使用。

2、懒汉式写法2（同步方法，线程安全）

package singleton.type4;

public class TestSingleton04 {
	public static void main(String[] args) {
		//模拟多线程下线程不安全问题
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};

		}.start();
		
		//其他线程复制上面的线程即可
	}
}

class Singleton {

	//1.构造器私有化
	private Singleton(){
	}

	//2.静态实例对象
	private static Singleton instance;

	//3.在调用时实例化对象，同步方法
	public static synchronized Singleton getInstance(){
		if(instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
}
说明：
1）解决了线程安全问题
2）效率低

因为加了同步锁，当有线程进入方法获取实例时，其他线程都要在外面等待。而实际上是只要判断instance为null时才需要创建实例，instance不为null时，只需要return就行了。

结论：在实际开发中，不推荐使用。

3、懒汉式写法3（同步代码块，双重检查，线程安全）

package singleton.type5;

public class TestSingleton05 {
	public static void main(String[] args) {
		//模拟多线程下线程不安全问题
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};

		}.start();
		//其他线程复制上面的线程即可
	}
}

class Singleton {

	//1.构造器私有化
	private Singleton(){
	}

	//2.静态实例对象
	private static Singleton instance;

	//3.在调用时实例化对象
	public static Singleton getInstance(){
		if(instance == null) {
			//4.同步代码块
			synchronized(Singleton.class){
				//5.双重检查
				if(instance == null){
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}
说明：
1）解决了线程安全问题，提高了效率。
2）提高了效率

当线程A第一次判断instance为null时，进入if，再次判断instance为null，进入if，此时还没有创建实例，线程B第一次判断instance为null，进入if，由于线程A已经进入，加锁了，无法进行第二次if判断，此时线程A创建实例结束，线程B进入第二次if判断instance不为null，直接返回。当后续有线程获取实例时，只需要进行第一次if判断，instance不为null，就直接返回，提高了效率。
在这里插入图片描述

结论：实现Lazy Loading ，线程安全，效率高，实际开发中推荐使用。

三、静态内部类实现单例（线程安全，效率高）

package singleton.type6;

public class TestSingleton06 {
	public static void main(String[] args) {
		//模拟多线程下线程不安全问题
		new Thread(){
			public void run() {
				Singleton instance = Singleton.getInstance();
				System.out.println(Thread.currentThread().getName() + ": instance.hashCode = " + instance.hashCode());
			};

		}.start();
		
		//其他线程复制上面的线程即可
	}
}

class Singleton {

	//1.构造器私有化
	private Singleton(){
	}

	//2.静态内部类
	private static class Instance {
		private static final Singleton INSTANCE = new Singleton();
	}
	
	public static Singleton getInstance(){
		return Instance.INSTANCE;
	}
}
说明：
1）延迟加载

静态内部类并不会随着主类的加载而加载，而是在调用时才会加载，所以实现了LazyLoading。

2）线程安全

类的静态属性只会在类第一次加载时初始化，在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程时无法进入的。

结论：线程安全，延迟加载，效率高，实际开发中推荐使用。

四、枚举实现单例

package singleton.type7;

public class TestSingleton07 {
	public static void main(String[] args) {
		Singleton instance1 = Singleton.INSTANCE;
		Singleton instance2 = Singleton.INSTANCE;
		System.out.println(instance1 == instance2);
		System.out.println("instance1.hashCode = " + instance1.hashCode());
		System.out.println("instance2.hashCode = " + instance2.hashCode());
	}
}

enum Singleton {
	
	INSTANCE;
	
}
说明：
1）避免线程安全问题
2）防止反序列化重新创建对象。
结论：实际开发中推荐使用
qq_24552437
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式-单例模式详解
11-24
Java设计模式-单例模式详解
java设计模式-单例.pdf
05-16
设计模式 java设计模式-单例.pdf
JAVA-设计模式-创建型模式-单例模式
08-10
JAVA-设计模式-创建型模式-单例模式
java设计模式-单例模式
02-27
设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段...
常见设计模式-单例模式
07-06
单例模式，完整介绍单例模式的几种创建方式 以及对比优缺点，引用spring 源码简单分析 框架如何保证单例
【设计模式深度剖析】【1】【结构型】【代理模式】| 玩游戏打怪、升级为例加深理解
最新发布
浣花御劍
05-20 748
玩游戏打怪、升级为例深入理解代理模式
Java设计模式-备忘录模式（23）
艾利克斯冰的博客
05-17 17
备忘录模式
软件设计原则
Ftworld21的专栏
05-14 153
solid原则，dry原则，kiss原则。
【Python设计模式07】工厂方法模式
weixin_55252589的博客
05-20 194
pass")pass工厂方法模式是一种创建型设计模式，通过定义一个用于创建对象的接口，将对象的创建过程延迟到子类，从而提高代码的灵活性和可扩展性。通过使用工厂方法模式，可以在不修改现有代码的情况下增加新产品，减少了代码耦合，提高了系统的可维护性。合理应用工厂方法模式，可以显著提升代码质量和设计水平。
js设计模式： 单例模式
qq_36413371的博客
05-15 135
确保一个类只有一个实例存在。并提供一个全局的访问点,而且只能通过静态方法来获取。相比单例模式，它只能通过new方法获取。
Java设计模式-责任链模式（17）
艾利克斯冰的博客
05-16 12
责任链模式提供了一种优雅的方式来组织和管理请求的处理流程，它不仅降低了请求发送者与接收者之间的耦合度，还为系统的扩展和维护创造了良好基础。通过灵活的设计，可以适应多种复杂的业务场景，是解决请求处理问题的有效手段之一。然而，其使用也需注意平衡系统复杂度与性能需求，确保模式的应用既满足功能需求，又保持了系统的高效与简洁。
【设计模式】JAVA Design Patterns——Bridge（桥接模式）
CSBIGDOG的博客
05-20 386
考虑一下你拥有一种具有不同附魔的武器，并且应该允许将具有不同附魔的不同武器混合使用。为每个附魔创建每种武器的多个副本，还是只是创建单独的附魔并根据需要为武器设置它？桥接模式使您可以进行第二次操作。桥接模式是一个更推荐组合而不是继承的模式。将实现细节从一个层次结构推送到具有单独层次结构的另一个对象。桥接模式是软件工程中使用的一种设计模式，旨在“将抽象与其实现分离，从而使两者可以独立变化”将抽象与其实现分离，以便二者可以独立变化。
【Python设计模式05】装饰模式
weixin_55252589的博客
05-20 259
pass)"装饰模式是一种结构型设计模式，通过创建装饰类来包裹原始类，实现动态地给对象添加新功能。装饰模式遵循开闭原则，使得系统更具灵活性和可扩展性。尽管装饰模式会增加系统的复杂性，但在需要动态扩展对象功能的场景中，装饰模式是一种非常有用的设计模式。合理应用装饰模式，可以显著提高代码的可维护性和可复用性。
6、设计模式之桥接模式
天空之蓝的博客
05-18 755
分离抽象实现: 将抽象部分与它的具体实现部分分离,使它们都可以独立的变化;独立的变化 就是 在一定程度上 进行解耦;组合方式: 通过组合的方式建立两个类之间的联系, 而不是继承;桥接模式类型: 结构型;桥接模式 相当于 使用桥梁 将两侧连接起来 , 这里指的是 使用桥梁 连接两个类 , 在两个类之间建立某种联系 , 可以通过继承 , 也可以通过组合 , 桥接模式 是采用 组合的方式 , 建立两个类之间的关系;合成复用原则 , 推荐优先使用组合 , 不是继承;
【设计模式深度剖析】【2】【创建型】【工厂方法模式】
浣花御劍
05-16 848
定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。
设计模式--模板方法模式
简介
05-20 95
模板方法模式是一种行为设计模式，它定义了一个操作中的算法的骨架，而将一些步骤延迟到子类中实现。这种模式在许多应用场景中非常有用，例如在实现算法的通用框架、代码重用、封装实现细节以及确保算法的正确执行时。
设计模式：备忘录模式
K___End的博客
05-14 537
备忘录模式（Memento Pattern）是一种行为设计模式，它的主要目的是在不破坏对象的封装性的前提下，捕获并存储一个对象的内部状态，以便在将来需要时恢复该对象到之前的状态。这种模式非常适合需要实现撤销操作或状态恢复的场景，比如文本编辑器的撤销功能、游戏中的存档与读档功能等。
韵搜坊 -- 聚合接口优化(设计模式)
诨号无敌鸭的博客
05-17 1219
文章目录门面模式适配器模式后端数据源统一接口图片适配器帖子适配器用户适配器修改SearchFacade注册器模式注册器SearFacade类又精简了 门面模式 帮助我们用户（客户端）去更轻松的实现功能，不需要关心门面背后的细节，当调用你接口的客户端觉得麻烦的时候，是不是就可以抽象成一个门面了？ 后端 将controller层的业务代码抽象到manager/SearchFacade中 前端 IndexPage代码改造为加载单类数据 <template> <div class="index
C++ QT设计模式：解释器模式
buhuiCyvyan的博客
05-14 224
定义了解释器的接口，通常包括一个 interpret() 方法，用于解释语言中的表达式。
聊聊设计模式-单例模式
09-29
单例模式是一种创建型设计模式，它保证类仅有一个实例，并提供一个全局访问点。在单例模式中，类会自行创建一个实例，并对外提供一个访问该实例的方法。 单例模式有多种实现方式，其中常见的有懒汉式和饿汉式。懒汉...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值