Day804.原型模式与享元模式 -Java 性能调优实战
admin
2024-01-30 22:04:52
0

原型模式与享元模式

Hi,我是阿昌,今天学习记录的是关于原型模式与享元模式

原型模式享元模式:

  • 前者是在创建多个实例时,对创建过程的性能进行调优;
  • 后者是用减少创建实例的方式,来调优系统性能。

这么看,会不会觉得两个模式有点相互矛盾呢?其实不然,它们的使用是分场景的。

在有些场景下,需要重复创建多个实例,例如在循环体中赋值一个对象,此时就可以采用原型模式来优化对象的创建过程;

在有些场景下,则可以避免重复创建多个实例,在内存中共享对象就好了。


一、原型模式

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

因为 Object 类的 clone 方法是一个本地方法,它可以直接操作内存中的二进制流,所以性能相对 new 实例化来说,更佳。

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;  stu2.setName("test2");  System.out.println("学生1:" + stu1.getName());  System.out.println("学生2:" + stu2.getName());  }  
}

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

学生1:test1
学生2:test2

然而,实际上是:

学生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();  //创建学生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

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 setTeacher(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; } 

3、适用场景

在一些重复创建对象的场景下,就可以使用原型模式来提高对象的创建性能

例如,在开头提到的,循环体内创建对象时,就可以考虑用 clone 的方式来实现。

例如:

for(int i=0; iStudent stu = new Student(); ...
}

我们可以优化为:

Student stu = new Student(); 
for(int i=0; iStudent stu1 = (Student)stu.clone();...
}

除此之外,原型模式在开源框架中的应用也非常广泛。

例如 Spring 中,@Service 默认都是单例的。

用了私有全局变量,若不想影响下次注入或每次上下文获取 bean,就需要用到原型模式,可以通过以下注解来实现,@Scope(“prototype”)。


二、享元模式

享元模式是运用共享技术有效地最大限度地复用细粒度对象的一种模式。

该模式中,以对象的信息状态划分,可以分为内部数据和外部数据。内部数据是对象可以共享出来的信息,这些信息不会随着系统的运行而改变;外部数据则是在不同运行时被标记了不同的值。

享元模式一般可以分为三个角色:

  • Flyweight(抽象享元类)
  • ConcreteFlyweight(具体享元类)
  • FlyweightFactory(享元工厂类)

抽象享元类通常是一个接口或抽象类,向外界提供享元对象的内部数据或外部数据;

具体享元类是指具体实现内部数据共享的类;

享元工厂类则是主要用于创建和管理享元对象的工厂类。

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 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、适用场景

享元模式在实际开发中的应用也非常广泛。

例如 Java 的 String 字符串,在一些字符串常量中,会共享常量池中字符串对象,从而减少重复创建相同值对象,占用内存空间。

代码如下:

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

还有,在日常开发中的应用。

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


三、总结

两种模式无论是在开源框架,还是在实际开发中,应用都十分广泛。

在不得已需要重复创建大量同一对象时,可以使用原型模式,通过 clone 方法复制对象,这种方式比用 new 和序列化创建对象的效率要高;

在创建对象时,如果我们可以共用对象的内部数据,那么通过享元模式共享相同的内部数据的对象,就可以减少对象的创建,实现系统调优。


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

  • 单例模式,就是单个实例的模式,一般针对类来说的,也就是类实例,一个单例模式包含一个类实例。

  • 享元模式,就是共享元对象的模式,元对象除了可以是类实例,也可以是其他可以共享的对象,比如普通类型变量,字符常量等。一个享元模式可以包含多个元对象。

简单说就是,享元模式是单例模式的超集,单例模式是享元模式的子集。


new一个对象和clone一个对象,性能差在哪里呢?

一个对象通过new创建的过程为:
1、在内存中开辟一块空间;
2、在开辟的内存空间中创建对象;
3、调用对象的构造函数进行初始化对象。

而一个对象通过clone创建的过程为:
1、根据原对象内存大小开辟一块内存空间;
2、复制已有对象,克隆对象中所有属性值。

相对new来说,clone少了调用构造函数。如果构造函数中存在大量属性初始化或大对象,则使用clone的复制对象的方式性能会好一些。

相关内容

热门资讯

安卓9.0系统挂机游戏,轻松享... 你有没有发现,自从安卓9.0系统更新后,手机里的游戏体验简直就像坐上了火箭!今天,就让我带你一起探索...
安卓系统怎么用迅雷下载,安卓系... 你有没有想过,在安卓系统上下载文件竟然也能这么简单?没错,今天就要来给你揭秘,如何用迅雷在安卓系统上...
安卓手机刷成学生系统,探索全新... 你有没有想过,你的安卓手机其实可以变身成一个充满学习氛围的学生系统呢?没错,就是那种看起来简洁、功能...
ios能迁移安卓系统吗,iOS... 你有没有想过,你的iPhone里的那些宝贝应用,能不能搬到安卓手机上继续使用呢?这可是不少手机用户的...
荣耀10安卓11系统,畅享极致... 你知道吗?最近手机界可是热闹非凡呢!荣耀10这款手机,自从升级到了安卓11系统,简直就像脱胎换骨了一...
安卓系统pc版电脑配置,打造流... 你有没有想过,安卓系统竟然也能在电脑上运行呢?没错,就是那个我们手机上常用的安卓系统,现在也能在PC...
tcllinux系统刷安卓系统... 你有没有想过,你的TCL Linux系统竟然也能升级成安卓系统呢?没错,就是那个我们日常使用的安卓系...
安卓13系统更新蓝牙,蓝牙功能... 你有没有发现,最近你的安卓手机好像变得不一样了?没错,就是那个神秘的安卓13系统更新,它悄悄地来到了...
安卓系统钉钉打开声音,安卓系统... 你有没有遇到过这种情况?手机里装了钉钉,可每次打开它,那声音就“嗖”地一下跳出来,吓你一跳。别急,今...
理想汽车操作系统安卓,基于安卓... 你有没有想过,一辆汽车,除了能带你去你想去的地方,还能像智能手机一样,给你带来智能化的体验呢?没错,...
安卓系统越狱还能升级吗,升级之... 你有没有想过,你的安卓手机越狱后,还能不能愉快地升级系统呢?这可是不少手机爱好者关心的大问题。今天,...
安卓系统蓝牙耳机拼多多,畅享无... 你有没有发现,最近蓝牙耳机在市场上可是火得一塌糊涂呢!尤其是安卓系统的用户,对于蓝牙耳机的要求那可是...
安卓变苹果系统桌面,桌面系统变... 你知道吗?最近有个大新闻在科技圈里炸开了锅,那就是安卓用户纷纷转向苹果系统桌面。这可不是闹着玩的,这...
鸿蒙系统怎么下安卓,鸿蒙系统下... 你有没有想过,你的手机里那个神秘的鸿蒙系统,竟然也能和安卓世界来一场亲密接触呢?没错,今天就要来揭秘...
手机安卓系统流程排行,便捷操作... 你有没有发现,现在手机的世界里,安卓系统就像是个大舞台,各种版本层出不穷,让人眼花缭乱。今天,就让我...
安卓系统左上角hd,左上角HD... 你有没有发现,每次打开安卓手机,左上角那个小小的HD标识总是默默地在那里,仿佛在诉说着什么?今天,就...
安卓系统软件文件,架构解析与功... 你有没有发现,手机里的安卓系统软件文件就像是一个神秘的宝库,里面藏着无数的宝藏?今天,就让我带你一起...
安卓系统输入法回车,探索安卓输... 你有没有发现,在使用安卓手机的时候,输入法回车键的奇妙之处?它就像是我们指尖的魔法师,轻轻一点,文字...
安卓修改系统时间的软件,轻松掌... 你有没有想过,有时候手机上的时间不对劲,是不是觉得生活节奏都被打乱了?别急,今天就来给你揭秘那些神奇...
安卓系统能改成鸿蒙吗,系统迁移... 你有没有想过,你的安卓手机能不能变成一个鸿蒙系统的“小清新”呢?这可不是天方夜谭哦,今天就来聊聊这个...