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

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

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

今天我们就来看看这两种模式的适用场景，了解了这些你就可以更高效地使用它们提升系统性能了。

1、原型模式

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

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

1.1、实现原型模式

我们现在通过一个简单的例子来实现一个原型模式：

   // 实现 Cloneable 接口的原型抽象类 Prototype class Prototype implements Cloneable {// 重写 clone 方法public Prototype clone(){Prototype prototype = null;try{prototype = (Prototype)super.clone();}catch(CloneNotSupportedException e){e.printStackTrace();}return prototype;}}// 实现原型类class ConcretePrototype extends Prototype{public void show(){System.out.println(" 原型模式实现类 ");}}public class Client {public static void main(String[] args){ConcretePrototype cp = new ConcretePrototype();for(int i=0; i< 10; i++){ConcretePrototype clonecp = (ConcretePrototype)cp.clone();clonecp.show();}}}

要实现一个原型类，需要具备三个条件：

  • 实现 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 的值也就跟着被修改了。

我们可以通过一个简单的例子来看看普通的对象复制问题：

class Student {  private String name;  public String getName() {  return name;  }  public void setName(String name) {  this.name= name;  }  }  
public class Test {  public static void main(String args[]) {  Student stu1 = new Student();  stu1.setName("test1");  Student stu2 = stu1;  stu1.setName("test2");  System.out.println(" 学生 1:" + stu1.getName());  System.out.println(" 学生 2:" + stu2.getName());  }  
}

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

学生 1:test1
学生 2:test2

然而，实际上是：

学生 2: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();  // 创建学生 1stu1.setName("test1");  Student stu2 = stu1.clone();  // 通过克隆创建学生 2stu2.setName("test2");  System.out.println(" 学生 1:" + stu1.getName());  System.out.println(" 学生 2:" + stu2.getName());  }  
}

运行结果：

学生 1:test1
学生 2:test2

1.2、深拷贝和浅拷贝

在调用 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 (); // 定义老师 1teacher.setName(" 刘老师 ");Student stu1 = new Student();  // 定义学生 1stu1.setName("test1");           stu1.setTeacher(teacher);Student stu2 = stu1.clone(); // 定义学生 2stu2.setName("test2");  stu2.getTeacher().setName(" 王老师 ");// 修改老师System.out.println(" 学生 " + stu1.getName + " 的老师是:" + stu1.getTeacher().getName);  System.out.println(" 学生 " + stu1.getName + " 的老师是:" + stu2.getTeacher().getName);  }  
}

运行结果：

学生 test1 的老师是：王老师
学生 test2 的老师是：王老师

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

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

   public Student clone() { Student student = null; try { student = (Student) super.clone(); Teacher teacher = this.teacher.clone();// 克隆 teacher 对象student.setTeacher(teacher);} catch (CloneNotSupportedException e) { e.printStackTrace(); } return student; }

1.3、适用场景

前面我详讲了原型模式的实现原理，那到底什么时候我们要用它呢？

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

例如：

for(int i=0; i<list.size(); i++){Student stu = new Student(); ...
}

我们可以优化为：

Student stu = new Student(); 
for(int i=0; i<list.size(); i++){Student stu1 = (Student)stu.clone();...
}

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

2、享元模式

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

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

2.1、实现享元模式

我们还是通过一个简单的例子来实现一个享元模式：

// 抽象享元类
interface Flyweight {// 对外状态对象void operation(String name);// 对内对象String getType();
}
// 具体享元类
class ConcreteFlyweight implements Flyweight {private String type;public ConcreteFlyweight(String type) {this.type = type;}@Overridepublic void operation(String name) {System.out.printf("[类型 (内在状态)] - [%s] - [名字 (外在状态)] - [%s]\n", type, name);}@Overridepublic String getType() {return type;}
}
// 享元工厂类
class FlyweightFactory {private static final Map<String, Flyweight> FLYWEIGHT_MAP = new HashMap<>();// 享元池，用来存储享元对象public static Flyweight getFlyweight(String type) {if (FLYWEIGHT_MAP.containsKey(type)) {// 如果在享元池中存在对象，则直接获取return FLYWEIGHT_MAP.get(type);} else {// 在响应池不存在，则新创建对象，并放入到享元池ConcreteFlyweight flyweight = new ConcreteFlyweight(type);FLYWEIGHT_MAP.put(type, flyweight);return flyweight;}}
}
public class Client {public static void main(String[] args) {Flyweight fw0 = FlyweightFactory.getFlyweight("a");Flyweight fw1 = FlyweightFactory.getFlyweight("b");Flyweight fw2 = FlyweightFactory.getFlyweight("a");Flyweight fw3 = FlyweightFactory.getFlyweight("b");fw1.operation("abc");System.out.printf("[结果 (对象对比)] - [%s]\n", fw0 == fw2);System.out.printf("[结果 (内在状态)] - [%s]\n", fw1.getType());}
}

输出结果：

[类型 (内在状态)] - [b] - [名字 (外在状态)] - [abc]
[结果 (对象对比)] - [true]
[结果 (内在状态)] - [b]

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

2.2、适用场景

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

 String s1 = "hello";String s2 = "hello";System.out.println(s1==s2);//true

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

3、总结

通过以上讲解，相信你对原型模式和享元模式已经有了更清楚的了解了。两种模式无论是在开源框架，还是在实际开发中，应用都十分广泛。

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

4、思考题

上一讲的单例模式和这一讲的享元模式都是为了避免重复创建对象，你知道这两者的区别在哪儿吗？

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/161974.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

数据库语句执行流程（查询原理）SQL

数据库语句执行流程（查询原理）SQL

阅读更多...
TC397 EB MCAL开发从0开始系列 之 [15.1] Fee配置 - 双扇区demo

TC397 EB MCAL开发从0开始系列 之 [15.1] Fee配置 - 双扇区demo

一、Fee配置1、配置目标2、目标依赖2.1 硬件使用2.2 软件使用2.3 新增模块3、EB配置3.1 配置讲解3.2 模块配置3.2.1 MCU配置3.2.2 PORT配置3.2.3 Fls_17_Dmu配置3.2.4 Fee配置3.2.5 Irq配置3.2.6 ResourceM配置4、ADS代码编写及调试4.1 工程编译4.2 测试结果4.3 测例源码->
阅读更多...
2023年学习Go语言是否值得？探索Go语言的魅力

2023年学习Go语言是否值得？探索Go语言的魅力

关注公众号【爱发白日梦的后端】分享技术干货、读书笔记、开源项目、实战经验、高效开发工具等&#xff0c;您的关注将是我的更新动力&#xff01; 作为一门流行且不断增长的编程语言&#xff0c;Go语言在2023年是否值得学习呢&#xff1f;让我们来看看学习Go语言的好处以及为何…
阅读更多...
Java使用Maven打包jar包的全部方式

Java使用Maven打包jar包的全部方式

1. spring-boot-maven-plugin插件&#xff08;在springboot项目中使用&#xff09; <plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId><executions><execution><goals>…
阅读更多...
1410.HTML 实体解析器

1410.HTML 实体解析器

​​题目来源&#xff1a; leetcode题目&#xff0c;网址&#xff1a;1410. HTML 实体解析器 - 力扣&#xff08;LeetCode&#xff09; 解题思路&#xff1a; 使用map存放特殊字符串及其应被替换为的字符串。然后遍历字符串替换 map 中的字符串即可。 解题代码&#xff1a; …
阅读更多...
ubuntu 手动清理内存cache

ubuntu 手动清理内存cache

/proc是一个虚拟文件系统&#xff0c;我们可以通过对它的读写操作来做为与kernel实体间进行通信的一种手段。也就是说可以通过修改/proc中的文件&#xff0c;来对当前kernel的行为做出调整。 那么我们可以通过调整/proc/sys/vm/drop_caches来释放内存。操作如下&#xff1a; …
阅读更多...
富士康转移产线和中国手机海外设厂，中国手机出口减少超5亿部

富士康转移产线和中国手机海外设厂，中国手机出口减少超5亿部

富士康和苹果转移生产线对中国手机制造造成了巨大的影响&#xff0c;除此之外&#xff0c;中国手机企业纷纷在海外设厂也在减少中国手机的出口&#xff0c;2022年中国的手机出口较高峰期减少了5.2亿部。 手机是中国的大宗出口商品&#xff0c;不过公开的数据显示2022年中国的手…
阅读更多...
每日OJ题_算法_双指针_力扣202. 快乐数

每日OJ题_算法_双指针_力扣202. 快乐数

力扣202. 快乐数 202. 快乐数 - 力扣&#xff08;LeetCode&#xff09; 难度 简单 编写一个算法来判断一个数 n 是不是快乐数。 「快乐数」 定义为&#xff1a; 对于一个正整数&#xff0c;每一次将该数替换为它每个位置上的数字的平方和。然后重复这个过程直到这个数变为…
阅读更多...
RT-Thread 线程间同步【信号量、互斥量、事件集】

RT-Thread 线程间同步【信号量、互斥量、事件集】

线程间同步 一、信号量1. 创建信号量2. 获取信号量3. 释放信号量4. 删除信号量5. 代码示例 二、互斥量1. 创建互斥量2. 获取互斥量3. 释放互斥量4. 删除互斥量5. 代码示例 三、事件集1. 创建事件集2. 发送事件3. 接收事件4. 删除事件集5. 代码示例 简单来说&#xff0c;同步就是…
阅读更多...
PDF转成图片

PDF转成图片

使用开源库Apache PDFBox将PDF转换为图片 依赖 <dependency><groupId>org.apache.pdfbox</groupId><artifactId>fontbox</artifactId><version>2.0.4</version> </dependency> <dependency><groupId>org.apache…
阅读更多...
DockerHub 无法访问 - 解决办法

DockerHub 无法访问 - 解决办法

背景 DockerHub 镜像仓库地址 https://hub.docker.com/ 突然就无法访问了，且截至今日（2023/11）还无法访问。 这对我们来说，还是有一些影响的： ● 虽然 DockerHub 页面无法访问，但是还是可以下载镜像的，只是比较慢而已 ● 没法通过界面查询相关镜像，或者维护相关镜像了…
阅读更多...
JAVA 使用stream流将List中的对象某一属性创建新的List

JAVA 使用stream流将List中的对象某一属性创建新的List

JAVA 使用stream流将List中的对象某一属性创建新的List 1.stream流介绍 Java Stream是Java 8引入的一种新机制&#xff0c;它可以让我们以声明式方式操作集合数据&#xff0c;提供了更加简洁、优雅的集合处理方式。Stream是一个来自数据源的元素队列&#xff0c;并支持聚合操…
阅读更多...
【Rxjava详解】(二) 操作符的妙用

【Rxjava详解】(二) 操作符的妙用

文章目录 接口变化操作符mapflatmapdebouncethrottleFirst()takeconcat RxJava 是一个基于 观察者模式的异步编程库&#xff0c;它提供了丰富的操作符来处理和转换数据流。 操作符是 RxJava 的核心组成部分&#xff0c;它们提供了一种灵活、可组合的方式来处理数据流&#xf…
阅读更多...
C++二分算法：得到子序列的最少操作次数

C++二分算法：得到子序列的最少操作次数

本文涉及的基础知识点 二分查找算法合集 题目 给你一个数组 target &#xff0c;包含若干 互不相同 的整数&#xff0c;以及另一个整数数组 arr &#xff0c;arr 可能 包含重复元素。 每一次操作中&#xff0c;你可以在 arr 的任意位置插入任一整数。比方说&#xff0c;如果…
阅读更多...
【如何学习Python自动化测试】—— 多层窗口定位

【如何学习Python自动化测试】—— 多层窗口定位

6 、 多层窗口定位 多层窗口指的是在操作系统图形界面中&#xff0c;一个窗口被另一个窗口覆盖的情况。在多层窗口中&#xff0c;如何定位需要操作的窗口&#xff1f; 一种常见的方法是使用操作系统提供的AltTab快捷键&#xff0c;可以在打开的所有窗口中快速切换焦点。如果需要…
阅读更多...
第十三章 控制值的转换 - 处理UTC时区指示符

第十三章 控制值的转换 - 处理UTC时区指示符

文章目录 第十三章 控制值的转换 - 处理UTC时区指示符 第十三章 控制值的转换 - 处理UTC时区指示符 对于支持XML的类&#xff0c;可以指定在从XML文档导入时是否使用UTC时区指示符。同样&#xff0c;可以指定是否在导出时包含UTC时区指示符。 为此&#xff0c;指定XMLTIMEZON…
阅读更多...
GEE生物量碳储量——利用sens和MK检验方法计算1987-2022年森林地上生物量AGB和碳储量的时空变化特征

GEE生物量碳储量——利用sens和MK检验方法计算1987-2022年森林地上生物量AGB和碳储量的时空变化特征

简介： 本文是将之前已经处理好的森林生物量和碳储量数据保存到GEE Assets中，然后分别将单张影像导入到代码编辑器中，构建一个时间序列集合，并且这里需要用到的是我们给影像添加指定的时间属性，这样方便进行下一步的时序分析和空间预测。 首先，需要收集1987年至2022年期…
阅读更多...
C语言实现Linux下TCP Server测试工具

C语言实现Linux下TCP Server测试工具

Linux TCP Server测试工具代码 实现了接受数据并输出文本和十六制字符串 #include <stdio.h> #include<string.h> #include <unistd.h> #include <stdlib.h> #include <errno.h> #include <signal.h> #include <arpa/inet.h> #incl…
阅读更多...
STM32内存介绍

STM32内存介绍

ROM是一种只读存储器&#xff0c;经历了从NOR Flash到NAND Flash再到现在的eMMC的发展。为了便于使用和大批量生产&#xff0c;ROM进一步分为了4种类型&#xff1a;PROM、EPROM、EEPROM和Flash。PROM只能被编程一次&#xff0c;EPROM可擦写可编程且可达1000次&#xff0c;EEPRO…
阅读更多...
leetcode/hot100

leetcode/hot100

文章目录 一、哈希1.两数之和2.字母异位词分组3.最长连续序列 二、双指针4. 移动零5.盛最多水的容器6.三数之和7.接雨水 三、滑动窗口8.无重复字符的最长子串9.找到字符串中所有字母异位词 四、子串10.和为 K 的子数组 一、哈希 1.两数之和 1. 两数之和 class Solution { pu…
阅读更多...
最新文章

Copyright @ 2022~2023