4、设计模式之单例设计模式

已于 2022-11-24 15:42:25 修改
阅读量219 收藏
点赞数
分类专栏： Java # Java设计模式 面向对象 文章标签： 设计模式 单例模式 java
于 2022-11-02 10:58:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43113381/article/details/127646928
版权

单例设计模式

4.1 单例设计模式介绍

所谓类的单例设计模式（Singleton Design Pattern ），就是采取一定的方法保证在整个的软件系统中，使得某个类只存在一个对象实例，并且该类只提供一个取得其对象实例的方法(静态方法)。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

4.2 单例设计模式分类

  1. 饿汉式(静态常量)
  2. 饿汉式（静态代码块）
  3. 懒汉式(线程不安全)
  4. 懒汉式(线程安全，同步方法)
  5. 懒汉式(线程安全，同步代码块)
  6. 双重检查
  7. 静态内部类
  8. 枚举

4.3 饿汉式（静态常量）

步骤如下：

  1. 构造器私有化
  2. 创建一个静态的不可变的本类对象
  3. 提供一个静态的公有方法返回该对象

代码如下：

package d2_singleton.type1;

/**
 * 饿汉式单例设计模式的实现（使用静态常量）
 * @author luxianghai
 *
 */

public class SingletonDemo {

	public static void main(String[] args) {
		
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		
		System.out.println(instance1 == instance2); // true
	}
}

class Singleton {
	// 1.私有化构造器
	private Singleton() {
		
	}
	
	// 2.创建一个本类对象 - static、final
	private final static Singleton INSTANCE = new Singleton();
	
	// 3. 提供一个静态的公有方法获取实例
	public static Singleton getInstance() {
		return INSTANCE;
	}
}

优缺点分析：

  1. 优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
  2. 缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
  3. 这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法， 但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果

结论：这种单例模式可用，但可能造成内存浪费

4.4 饿汉式（静态代码块）

代码如下：

package d2_singleton.type2;


/**
 * 饿汉式单例设计模式的实现（使用静态代码块实现）
 * @author luxianghai
 *
 */
public class SingletonDemo {

	public static void main(String[] args) {
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		
		System.out.println(instance1 == instance2); // true
	}

}

class Singleton {
	
	// 1.构造器私有化
	private Singleton() {
		
	}
	
	// 2.创建一个本类的成员
	private static Singleton instance;
	
	// 3.使用静态代码块初始化成员
	static {
		instance = new Singleton();
	}
	
	// 4.提供一个静态的公有方法获取实例
	public static Singleton getInstance() {
		return instance;
	}
	
}

 优缺点分析：这种方式和上面的方式其实类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面是一样的。

结论：这种单例模式可用，但是可能造成内存浪费

4.5 懒汉式(线程不安全)

代码如下：

package d2_singleton.type3;

/**
 * 懒汉式（线程不安全）
 * @author luxianghai
 *
 */
public class SingletonDemo {

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

}

class Singleton {
	// 1.私有化构造器
	private Singleton() {
		
	}
	
	// 2.创建静态成员变量
	private static Singleton instance;
	
	// 3.提供静态的公有方法获取实例
	public static Singleton getInstance() {
		if ( null == instance ) {
			instance = new Singleton();
		}
		return instance;
	}
}

 优缺点说明：

  1. 起到了Lazy Loading的效果，但是只能在单线程下使用。
  2. 如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式

结论：在实际开发中，不要使用这种方式.

4.6 懒汉式(线程安全，同步方法)

代码如下：

package d2_singleton.type4;

/**
 * 懒汉式（线程安全）
 * @author luxianghai
 *
 */
public class InstancetonDemo {

	public static void main(String[] args) {
		Singleton instance1 = Singleton.getInstance();
		Singleton instance2 = Singleton.getInstance();
		
		System.out.println(instance1 == instance2); // true
	}

}

class Singleton {
	// 1.私有化构造器
	private Singleton() {
		
	}
	// 2.创建成员静态变量
	private static Singleton instance;
	// 3.提供静态公有的方法获取对象实例
	public static synchronized Singleton getInstance() {
		if ( null == instance ) {
			instance = new Singleton();
		}
		return instance;
	}
}

 优缺点说明：

  1. 解决了线程不安全问题
  2. 效率太低，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低

结论：在实际开发中，不推荐使用这种方式

4.7 懒汉式(线程安全，同步代码块)

代码如下：

package d2_singleton.type5;


/**
 * 饿汉式（线程安全，同步代码块）
 * @author luxianghai
 *
 */
public class SingletonDemo {

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

}

class Singleton {
	
	//1.私有化构造器
	private Singleton() {
		
	}
	//2.创建静态成员变量
	private static Singleton instance;
	//3.提供静态公有方法来获取对象实例
	public static Singleton getInstance() {
		if ( null == instance ) {
			synchronized(Singleton.class) {
				instance = new Singleton();
			}
		}
		return instance;
	}
}

 优缺点说明：

  1. 这种方式，本意是想对第四种实现方式的改进，因为前面同步方法效率太低，改为同步产生实例化的的代码块
  2. 但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致，假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例

结论：在实际开发中，不能使用这种方式

4.8 双重检查

代码如下：

package d2_singleton.type6;
/**
 * 双重检查
 * @author luxianghai
 *
 */
public class SingletonDemo {

	public static void main(String[] args) {
		

	}

}

class Singleton {
	// 1.私有化构造器
	private Singleton() {
		
	}
	// 2.创建静态成员变量
	private volatile static Singleton instance;
	
	// 3.提供静态公有方法获取实例
	public static Singleton getInstance() {
		if ( null == instance ) {
			synchronized(Singleton.class) {
				if ( null == instance ) {
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}

 优缺点说明：

  1. Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次if (singleton == null)检查，这样就可以保证线程安全了。
  2. 这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接return实例化对象，也避免的反复进行方法同步.
  3. 线程安全；延迟加载；效率较高

 结论：在实际开发中，推荐使用这种单例设计模式

4.9 静态内部类

代码如下:

package d2_singleton.type7;
/**
 * 静态内部类实现单例设计模式
 * @author luxianghai
 *
 */
public class SingletonDemo {

	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		
		System.out.println(s1 == s2);
	}

}

class Singleton {
	//1.私有化构造器
	private Singleton() {
		
	}
	//2.创建静态内部类,该类提供一个静态常量
	static class Instance {
		public static final Singleton INSTANCE = new Singleton(); 
	}
	// 3.创建静态公有方法获取实例
	public static Singleton getInstance() {
		return Instance.INSTANCE;
	}
}

 优缺点说明：

  1. 这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
  2. 静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
  3. 类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们 保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
  4. 优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高

结论：推荐使用

4.10 枚举

代码如下：

package d2_singleton.type8;

/**
 * 枚举类实现单例设计模式
 * @author luxianghai
 *
 */
public class SingletonDemo {

	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		
		System.out.println(s1 == s2);
	}

}

class Singleton {
	//1.私有化构造器
	private Singleton() {
		
	}
	// 2.创建枚举类
	static enum SingletonEnum {
		INSTANCE;
		private Singleton instance;
		private SingletonEnum() {
			instance = new Singleton();
		}
		public Singleton getInstance() {
			return instance;
		}
	}
	
	public static Singleton getInstance() {
		return SingletonEnum.INSTANCE.getInstance();
	}
}

 优缺点说明：

  1. 这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。
  2. 这种方式是Effective Java作者Josh Bloch 提倡的方式

结论：推荐使用

4.11 存在的问题

以上实现单例的方方式中，枚举方式除外，使上面定义的单例类（Singleton）其实是可以创建多个对象的，有两种方式，分别是序列化和反射。下面我将给出解决方案：

4.11.1 解决序列化破坏单例

代码如下：

public class Singleton implements Serializable {

	private Singleton() {
		
	}

	static class Instance {
		private static final Singleton INSTANCE = new Singleton();
	}

	public static Singleton getInstance() {
		return Instance.INSTANCE;
	}
	// 加入该方法实现防止序列化造成多例
	public Object readResolve() throws ObjectStreamException {
		return Instance.INSTANCE;
	}
}

4.11.2 解决发射破坏单例

代码如下：

public class Singleton {

	private Singleton() {
		// 反射破解单例需要添加的代码
		if ( null != INSTANCE ) {
			throw new RuntimeException("请使用getInstance方法获取对象！！！");
		}
	}

	private static final Singleton INSTANCE = new Singleton();

	public static Singleton getInstance() {
		return INSTANCE;
	}
}

4.12 小结

  1. 单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能
  2. 当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new
  3. 单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)

相关文章索引

设计模式概述
UML类图
软件设计原则

后记

我水平有限，错误难免，还望各位加以指正。

本文内容到此结束，感谢您的阅读！！！如果内容对你有帮助的话，记得给我三连丫（点赞、收藏、关注）

4.O.4
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA设计模式之单例模式
09-22
JAVA设计模式之单例模式。 一篇文章带你快速了解！
JavaScript设计模式之单例模式详解
12-11
这一次重温一下《JavaScript设计模式与开发实践》，开篇为单例模式。 /** * pre 单例模式 * 定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点 * 应用：单例模式是一种常用的模式，有一些对象我们...
研磨设计模式之单例模式
02-27
 单例模式（Singleton）1 场景问题1.1 读取配置文件的内容考虑这样一个应用，读取配置文件的内容。很多应用项目，都有与应用相关的配置文件，这些配置文件多是由项目开发人员自定义的，在里面定义一些应用需要的...
c#设计模式之单例模式的实现方式
12-26
单例模式对于我们来说一点也不模式，是一个常见的名称，单例模式在程序中的实际效果就是：确保一个程序中只有一个实例，并提供一个全局访问点，节省系统资源 单例模式无论是在实际开发中还是在软件应用中比较常见，...
设计模式：桥接模式
最新发布
玉汝于成
05-06 560
接模式是一种对象结构型模式，它将抽象部分与它的实现部分分离，使它们都可以独立地变化。这种分离允许抽象和实现部分独立地扩展，而不会相互影响。桥接模式基于类的最小设计原则，通过封装、聚合及继承等行为让不同的类承担不同的职责。
设计模式（十）：装饰者模式
wenqi1992的博客
04-29 481
装饰者模式的介绍
C++11 设计模式6. 建造者模式，也叫做生成器模式
hunandede的博客
04-29 769
建造者模式（也被成为⽣成器模式），是⼀种创建型设计模式，软件开发过程中有的时候需要创建很复杂的对象，⽽建造者模式的主要思想是将对象的构建过程分为多个步骤，并为每个步骤定义⼀个抽象的接⼝。，构建过程相对复杂，⽽我们使⽤建造者模式将计算机的构建过程封装在⼀个具体的建造者类中，⽽指导者类则负责指导构建的步骤和顺序。每个具体的建造者类可以负责构建不同型号或配置的计算机，客户端代码可以通过选择不同的建造者来创建不同类型的计算机，这样就可以根据需要构建不同表示的复杂对象，更加灵活。
23种设计模式
weixin_72256328的博客
05-01 1065
23种设计模式
【学习vue 3.x】(一)基础内容
m0_74187147的博客
04-30 1663
Vue.js是一套构建用户界面的渐进式框架，采用自底向上增量开发的设计，核心库只关注视图层。另一方面，Vue完全有能力驱动采用单文件组件和Vue生态系统支持的库开发的复杂单页应用。 Vue是一个框架，也是一个生态。可以用不同的方式使用Vue： 无需构建步骤，渐进式增强静态的HTML； 在任何页面中作为Web Components嵌入； 单页应用 (SPA)； 全栈/服务端渲染 (SSR)； Jamstack/静态站点生成 (SSG)； 开发桌面端、移动端、WebGL，甚至是命令行终端中的界面。
设计模式: 工厂模式
m0_59925573的博客
05-02 636
定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。主要解决接口选择的问题。我们明确地计划不同条件下创建不同实例时。让其子类实现工厂接口，返回的也是一个抽象的产品。创建过程在其子类执行。1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。2、在 Hibernate 中，如果需要更换数据库，工厂模式同样发挥了作用。只需简单地更改方言（Dialect）和数据库驱动（Driver），就能够实现对不同数据库的切换。
设计模式之MVC模式
Rcain_R的博客
05-02 1184
MVC（Model-View-Controller）模式是一种软件设计模式，广泛应用于构建用户界面的软件架构中，特别是在Web应用程序开发中。
Python如何实现抽象工厂模式
一点
04-30 1199
在软件工程中，抽象工厂模式（Abstract Factory Pattern）是一种设计模式，用于在运行时创建一组相关或相互依赖的对象，而不需要指定它们的具体类。这种模式非常适合用于管理系统中对象的创建，同时保持这些对象之间的一致性和隔离性。抽象工厂模式涉及以下几个关键概念：抽象工厂（Abstract Factory）：提供一个创建一系列相关或依赖对象的接口，而不需要指定具体类。具体工厂（Concrete Factory）：实现抽象工厂接口，生产具体的产品对象。
设计模式一
hummhumm的专栏
05-04 700
单例模式简介。
设计模式学习笔记 - 项目实战三：设计实现一个支持自定义规则的灰度发布组件（实现）
chenjian723122704的专栏
04-30 838
到本章为止，项目实战环节就彻底结束了。在这一部分中，我们通过限流、幂等、灰度这三个实战项目，带你从需求分析、系统设计、代码实现三个环节，学习了如何进行功能性、非功能性需求分析，如何通过合理的设计，完成功能性需求，满足非功能性需求，以及如何编写高质量的代码实现。实际上，项目本身的分析、设计、实现并不重要，不必对细节过于纠结。希望通过这三个例子，分享思考思路、开发套路，让你借鉴并举一反三地应用到你的项目开发中。这才是最有价值的，才是你学习的重点。
【设计模式】之模板方法模式
小杰不秃头的博客
04-29 1136
今天给大家介绍23种设计模式中的模板方法模式，这个设计模式在Spring框架中还是挺常见的，手写Spring源码的小伙伴必须要掌握的设计模式之一，文章结构还是经典的三连问，是什么？为什么？怎么用？🌈
go设计模式之组合设计模式
shulu的专栏
04-29 680
将对象组合成树形结构以表示“部分-整体”的层次结构。组合设计模式使得用户对单个对象和组合对象的使用具有一致性。参与者Component为组合中的对象声明接口Leaf在组合中表示叶子节点对象。Composite存储子部件。访问和管理子部件。
设计模式：适配器模式
m0_59925573的博客
05-02 1392
这种情况下，客户(中国人)的期望接口是有一个220V的电压为电器充电，但实际的接口是仅有一个110V的电压供电器充电，这种情况下就需要采用一根电压转换器(适配器)使得110V的电压能够转换为220V的电压，供客户使用。想要建立一个可以重复使用的适配器类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口，但通过适配器使得它们都具有一致的接口。（比如老虎和飞禽，现在多了一个飞虎，在不增加实体的需求下，增加一个适配器，在里面包容一个虎对象，实现飞的接口。
设计模式的原则与分类
孟孟的博客
04-30 430
单一职责原则是接口隔离原则的基础，单一职责原则注重职责的划分，从职责角度进行类和接口的划分；迪米特法则 又叫做最少知道原则，一个类对于其他类知道得越少越好，简单来说就是只暴露方法入口，而实现细节不需要暴露给调用者。如果要修改一个功能，不是直接进行内部的代码修改，而是使用扩展的方式进行。结构型模式，更加注重类或对象的结合方式，将类或对象进行结合，形成一个更大的结构，在该结构下，不同的组件扮演不同的角色。一个类只需要负责一种职责即可，一个类发生变化的原因，必然是所负责的职责发生变化。
设计模式学习笔记 - 项目实战三：设计实现一个支持自定义规则的灰度发布组件（分析）
chenjian723122704的专栏
04-29 865
灰度发布可以分为三个层面的灰度：产品层面的灰度、系统层面的灰度和代码层面的灰度。本章重点讲解代码层面的灰度，通过编程来控制是否执行新的代码逻辑，以及灰度执行新的代码逻辑。代码层面的灰度，主要解决代码质量问题，通过逐渐放量灰度执行，两降低重大代码改动带来的风险。在出问题之后，在不需要修改代码、重新部署、重启系统的情况下，实现快速的回滚。相对于系统层面的灰度，它可以做的更加细粒度，更加灵活、简单、好维护，但也存在着代码侵入的问题，灰度代码跟业务代码耦合在一起。
php语言设计模式之单例模式educoder
03-16
单例模式是一种常用的设计模式，它保证一个类只有一个实例，并提供一个全局访问点。在PHP中，可以通过定义一个私有的构造函数和一个静态的getInstance方法来实现单例模式。在getInstance方法中，如果类的实例不存在，则创建一个新的实例并返回，否则直接返回已有的实例。这样可以确保在整个应用程序中只有一个实例存在，避免了重复创建对象的开销和可能引发的问题。单例模式在实现数据库连接、日志记录等场景中非常常见。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值