原型模式与享元模式:提升系统性能的利器

这篇具有很好参考价值的文章主要介绍了原型模式与享元模式:提升系统性能的利器。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

        原型模式和享元模式,前者是在创建多个实例时,对创建过程的性能进行调优后者是用减
少创建实例的方式,来调优系统性能
。这么看,你会不会觉得两个模式有点相互矛盾呢?

          

        在有些场景下,我们需要重复创建多个实例,例如在循环体中赋值一个对象此时我们就可以采用原型模式来优化对象的创建过程;而在有些场景下,我们则可以避免重复创建多个实例,在内存中共享对象就好了    

 原型模型

原型模型的实现

原型模式是通过给出一个原型对象来指明所创建的对象的类型,然后使用自身实现的克隆接口来复制这个原型对象,该模式就是用这种方式来创建出更多同类型的对象。

使用这种方式创建新的对象的话,就无需再通过 new 实例化来创建对象了。这是因为Object 类的 clone 方法是一个本地方法,它可以直接操作内存中的二进制流,所以性能相对 new 实例化来说,更佳

new一个对象和clone一个对象,性能差在哪里呢?上边提到直接从内存复制二进制怎末理解?


答: 一个对象通过new创建的过程为:
1、在内存中开辟一块空间;
2、在开辟的内存空间中创建对象;
3、调用对象的构造函数进行初始化对象。
而一个对象通过clone创建的过程为:
1、根据原对象内存大小开辟一块内存空间;
2、复制已有对象,克隆对象中所有属性值。
相对new来说,clone少了调用构造函数。如果构造函数中存在大量属性初始化或大对象,则使用clone的复制对象的方式性能会好一些。

首先先看一段原型模式的代码

原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

要实现一个原型类,需要具备三个条件:

实现 Cloneable 接口:Cloneable 接口与序列化接口的作用类似,它只是告诉虚拟机可
以安全地在实现了这个接口的类上使用 clone 方法。在 JVM 中,只有实现了 Cloneable
接口的类才可以被拷贝,否则会抛出 CloneNotSupportedException 异常。
重写 Object 类中的 clone 方法:在 Java 中,所有类的父类都是 Object 类,而 Object
类中有一个 clone 方法,作用是返回对象的一个拷贝。
在重写的 clone 方法中调用 super.clone():默认情况下,类不具备复制对象的能力,需
要调用 super.clone() 来实现

从上面我们可以看出,原型模式的主要特征就是使用 clone 方法复制一个对象。通常,有
些人会误以为 Object a=new Object();Object b=a; 这种形式就是一种对象复制的过程,
然而这种复制只是对象引用的复制,也就是 a 和 b 对象指向了同一个内存地址,如果 b 修
改了,a 的值也就跟着被修改了。我们可以通过一个简单的例子来看看普通的对象复制问题:

原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

 如果是复制对象,此时打印的日志应该为:

原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

 然而,实际上是:

学生 1: test2

学生 2 :test2

通过 clone 方法复制的对象才是真正的对象复制,clone 方法赋值的对象完全是一个独立
的对象
。Object 类的 clone 方法是一个本地方法,它直接操作内存中的二进
制流,特别是复制大对象时,性能的差别非常明显。我们可以用 clone 方法再实现一遍以
上例子

// 学生类实现 Cloneable 接口
class Student implements Cloneable{
private String name; // 姓名
public String getName() {
return name;
}
public void setName(String name) {
this.name= name;
}
// 重写 clone 方法
public Student clone() {
Student student = null;
try {
student = (Student) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return student;
}
}
public class Test {
public static void main(String args[]) {
Student stu1 = new Student(); // 创建学生 1
stu1.setName("test1");
Student stu2 = stu1.clone(); // 通过克隆创建学生 2
stu2.setName("test2");
System.out.println(" 学生 1:" + stu1.getName());
System.out.println(" 学生 2:" + stu2.getName());
}
}

 运行结果:

学生 1:test1

学生 2:test2

深拷贝和浅拷贝

        在调用 super.clone() 方法之后,首先会检查当前对象所属的类是否支持 clone,也就是看
该类是否实现了 Cloneable 接口

        如果支持,则创建当前对象所属类的一个新对象,并对该对象进行初始化,使得新对象的成
员变量的值与当前对象的成员变量的值一模一样,但对于其它对象的引用以及 List 等类型
的成员属性,则只能复制这些对象的引用了。所以简单调用 super.clone() 这种克隆对象方
式,就是一种浅拷贝。

        所以,当我们在使用 clone() 方法实现对象的克隆时,就需要注意浅拷贝带来的问题。我们
再通过一个例子来看看浅拷贝。

// 定义学生类
class Student implements Cloneable{
private String name; // 学生姓名
private Teacher teacher; // 定义老师类
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Teacher getTeacher() {
return teacher;
}
public void setName(Teacher teacher) {
this.teacher = teacher;
}
//重写克隆方法
public Student clone() {
Student student = null;
try {
student = (Student) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return student;
}
}
// 定义老师类
class Teacher implements Cloneable{
private String name; // 老师姓名
public String getName() {
return name;
}
public void setName(String name) {
this.name= name;
}
// 重写克隆方法,堆老师类进行克隆
public Teacher clone() {
Teacher teacher= null;
try {
teacher= (Teacher) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return student;
}
}
public class Test {
public static void main(String args[]) {
Teacher teacher = new Teacher (); // 定义老师 1
teacher.setName(" 刘老师 ");
Student stu1 = new Student(); // 定义学生 1
stu1.setName("test1");
stu1.setTeacher(teacher);
Student stu2 = stu1.clone(); // 定义学生 2
stu2.setName("test2");
stu2.getTeacher().setName(" 王老师 ");// 修改老师
System.out.println(" 学生 " + stu1.getName + " 的老师是:" + stu1.getTeacher().get
System.out.println(" 学生 " + stu1.getName + " 的老师是:" + stu2.getTeacher().get
}
}

运行结果:

原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

观察以上运行结果,我们可以发现:在我们给学生 2 修改老师的时候,学生 1 的老师也跟
着被修改了。这就是浅拷贝带来的问题。 

我们可以通过深拷贝来解决这种问题,其实深拷贝就是基于浅拷贝来递归实现具体的每个对
,代码如下:

原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

 适用场景

在一些重复创建对象的场景下,我们就可以使用原型模式来提高对象的创建性能。例如,在开头提到的,循环体内创建对象时,我们就可以考虑用 clone 的方式来实现。

例如:

原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

可以优化为 :

原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

 除此之外,原型模式在开源框架中的应用也非常广泛。例如 Spring 中,@Service 默认都
是单例的。用了私有全局变量,若不想影响下次注入或每次上下文获取 bean,就需要用到
原型模式,我们可以通过以下注解来实现,@Scope(“prototype”)。

以上可能会有这个哥们们不理解比如这个问题

文中说的,@service默认是单例模式,若不想影响下次请求,就要使用原型模式?

回复:纠正下,不是每次请求,而是每次bean注入或通过上下文获取bean时。

如果我们使用的是单例,假设有一个全局变量private int a=1,我们通过上下文获取到实例,调用A方法修改了变量a=2,此时下一个通过上下文获取到实例调用B方法获取变量,则a=2。

如果我们使用的是原型模式,假设有一个全局变量private int a=1,我们通过上下文获取到实
例,调用A方法修改了变量a=2,此时下一个通过上下文获取到实例调用B方法获取变量,则还是a=1。

享元模式

        享元模式是运用共享技术有效地最大限度地复用细粒度对象的一种模式。该模式中,以对象
的信息状态划分,可以分为内部数据和外部数据内部数据是对象可以共享出来的信息,这
些信息不会随着系统的运行而改变;外部数据则是在不同运行时被标记了不同的值。

        享元模式一般可以分为三个角色,分别为 Flyweight(抽象享元类)、
ConcreteFlyweight(具体享元类)和 FlyweightFactory(享元工厂类)。抽象享元类通
常是一个接口或抽象类
,向外界提供享元对象的内部数据或外部数据具体享元类是指具体
实现内部数据共享的类;享元工厂类则是主要用于创建和管理享元对象的工厂类


原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

 原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

 原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

 

 原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

 这里注意内在数据,也就是线程共享的,这里咱们定义的是私有的String,大家会有欸他不是静态的怎末共享啊。???????????????????????

原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

 

观察以上代码运行结果,我们可以发现:如果对象已经存在于享元池中,则不会再创建该对
象了,而是共用享元池中内部数据一致的对象。这样就减少了对象的创建,同时也节省了同
样内部数据的对象所占用的内存空间。

适用场景

享元模式在实际开发中的应用也非常广泛。例如 Java 的 String 字符串,在一些字符串常
量中,会共享常量池中字符串对象,从而减少重复创建相同值对象,占用内存空间。代码如
下:

原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

 

原型模式与享元模式:提升系统性能的利器,设计模式,原型模式,享元模式

 在日常开发中的应用。例如,线程池就是享元模式的一种实现;将商品存储在应用服
务的缓存中,那么每当用户获取商品信息时,则不需要每次都从 redis 缓存或者数据库中获
取商品信息,并在内存中重复创建商品信息了。

  • 总结

在不得已需要重复创建大量同一对象时,我们可以使用原型模式,通过 clone 方法复制对
象,这种方式比用 new 和序列化创建对象的效率要高;在创建对象时,如果我们可以共用
对象的内部数据,那么通过享元模式共享相同的内部数据的对象,就可以减少对象的创建,
实现系统调优

一些杂谈

  • 线上短信业务被轰炸,流量费倍增……求推荐个解决思路,监测发现是爬虫程序

        建议加一个图片验证码文章来源地址https://www.toymoban.com/news/detail-626428.html

  • 这里需要考虑一个问题就是享元模式,在工厂哪用的那个hashmap的方式

到了这里,关于原型模式与享元模式:提升系统性能的利器的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 设计模式——享元模式

    享元模式(Flyweight Pattern)是池技术的重要实现方式。 使用共享对象可以有效地支持大量的细粒度对象。 优点 可以大大减少应用程序创建对象的数量,降低程序内存占用。 缺点 提高了系统的复杂度,需要分离出享元对象的外部状态(key)和内部状态(对象属性),并且外部

    2024年02月16日
    浏览(38)
  • 设计模式(22)享元模式

    一、介绍: 1、定义:享元模式(Flyweight Pattern)主要用于减少创建对象的数量,以减少内存占用和提高性能。这种类型的设计模式属于结构型模式,它提供了减少对象数量从而改善应用所需的对象结构的方式。 2、组成结构: (1)Flyweight(抽象享元类):通常是一个接口或

    2024年02月07日
    浏览(40)
  • 【23种设计模式】享元模式【⭐】

    个人主页 :金鳞踏雨 个人简介 :大家好,我是 金鳞 ,一个初出茅庐的Java小白 目前状况 :22届普通本科毕业生,几经波折了,现在任职于一家国内大型知名日化公司,从事Java开发工作 我的博客 :这里是CSDN,是我学习技术,总结知识的地方。希望和各位大佬交流,共同进

    2024年02月09日
    浏览(45)
  • js设计模式:享元模式

    当需要处理很多非常类似操作的时候,可以创建可以共享的对象,并暴露接口供其他对象调用 这个对象内包含这些操作的处理逻辑,可以优化性能  

    2024年02月22日
    浏览(37)
  • Java设计模式-享元模式

    在Java领域的软件开发中,设计模式是提高代码可维护性和可扩展性的重要工具。其中,享元模式是一种被广泛使用的设计模式,它通过优化对象的重用来提升系统性能。 享元模式是一种结构型设计模式,旨在通过共享对象来减少系统中的对象数量,从而提升性能和减少内存

    2024年02月06日
    浏览(36)
  • 设计模式-享元模式(Flyweight)

    享元模式(Flyweight Pattern)是一种结构型设计模式,它的主要目标是减少应用程序中对象的数量,以节省内存和提高性能。这一模式适用于对象数量庞大且相似的情况,通过共享内部状态来减少对象的创建。 在本篇博客中,我们将详细介绍享元模式的概念,并提供一个简单的

    2024年02月09日
    浏览(40)
  • 设计模式之享元模式

    本文看下一种结构型设计模式,享元模式。 当程序需要大量的重复对象,并且这些大量的重复对象只有部分属性不相同,其他都是相同的时候,就可以考虑使用享元设计模式设计模式来实现。典型的如围棋游戏中的棋子,除了颜色和位置不同外,其他都相同。射击游戏中的子

    2024年02月17日
    浏览(42)
  • 【前端设计模式】之享元模式

    享元模式是一种结构型设计模式,它通过共享对象来减少内存使用和提高性能。在前端开发中,享元模式可以用于优化大量相似对象的创建和管理,从而提高页面的加载速度和用户体验。 共享对象:享元模式通过共享相似对象来减少内存使用。相似对象可以共享一些不变的状

    2024年02月08日
    浏览(46)
  • 《设计模式的艺术》笔记 - 享元模式

            享元模式运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象,而这些对象都很相似,状态变化很小,可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象,因此它又称为轻量级模式,是一种对象结构型模式。 myclass.

    2024年01月19日
    浏览(45)
  • Java 设计模式系列:享元模式

    享元模式(Flyweight Pattern)是一种软件设计模式,用于减少内存使用和提高性能。它通过共享细粒度对象来减少创建和销毁对象时所需的内存。享元模式适用于大量相似对象的场景,这些对象可以共享相同的状态和行为。 享元模式的核心思想是将对象分为内部状态和外部状态

    2024年04月15日
    浏览(47)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包