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的复制对象的方式性能会好一些。

相关内容

热门资讯

编程安卓系统和鸿蒙主题,跨平台... 你有没有想过,手机的世界里,除了苹果的iOS和安卓的操作系统,还有个神秘的鸿蒙系统?今天,咱们就来聊...
哪个安卓机系统好用,探索安卓系... 你有没有想过,手机里的安卓系统就像是个大厨,不同的系统就像不同的烹饪手法,有的让你吃得津津有味,有的...
安卓如何控制苹果系统,从安卓到... 你知道吗?在这个科技飞速发展的时代,安卓和苹果两大操作系统之间的较量从未停歇。虽然它们各自有着忠实的...
安卓原生系统文件夹,安卓原生系... 你有没有发现,每次打开安卓手机,里面那些文件夹就像是一个个神秘的宝箱,里面藏着各种各样的宝贝?今天,...
基于安卓系统的游戏开发,从入门... 你有没有想过,为什么安卓手机上的游戏总是那么吸引人?是不是因为它们就像是你身边的好朋友,随时随地都能...
安卓系统怎样装驱动精灵,安卓系... 你那安卓设备是不是突然间有点儿不给力了?别急,今天就来手把手教你如何给安卓系统装上驱动精灵,让你的设...
如何本地安装安卓系统包,详细步... 你有没有想过,把安卓系统装在你的电脑上,是不是就像给电脑穿上了时尚的新衣?想象你可以在电脑上直接玩手...
安卓12卡刷系统教程,体验全新... 你有没有发现,你的安卓手机最近有点儿不给力了?运行速度慢得像蜗牛,是不是也想给它来个“换血大法”,让...
安卓系统无法打开swf文件,安... 最近是不是发现你的安卓手机有点儿不给力?打开SWF文件时,是不是总是出现“无法打开”的尴尬局面?别急...
鸿蒙系统依赖于安卓系统吗,独立... 你有没有想过,我们手机里的那个鸿蒙系统,它是不是真的完全独立于安卓系统呢?这个问题,估计不少手机控都...
适合安卓系统的图片软件,精选图... 手机里堆满了各种美美的照片,是不是觉得找起来有点头疼呢?别急,今天就来给你安利几款超级适合安卓系统的...
阴阳师安卓系统典藏,探寻阴阳师... 亲爱的阴阳师们,你是否在安卓系统上玩得如痴如醉,对那些精美的典藏式神们垂涎欲滴?今天,就让我带你深入...
安卓系统有碎片化缺点,系统优化... 你知道吗?在手机江湖里,安卓系统可是个响当当的大侠。它那开放、自由的个性,让无数手机厂商和开发者都为...
安卓4系统手机微信,功能解析与... 你有没有发现,现在市面上还有很多安卓4系统的手机在使用呢?尤其是那些喜欢微信的朋友们,这款手机简直就...
鸿蒙系统是安卓的盗版,从安卓“... 你知道吗?最近在科技圈里,关于鸿蒙系统的讨论可是热闹非凡呢!有人说是安卓的盗版,有人则认为这是华为的...
安卓系统怎么剪辑音乐,轻松打造... 你是不是也和我一样,手机里存了超多好听的歌,但是有时候想给它们来个变身,变成一段专属的旋律呢?别急,...
怎么把安卓手机系统变为pc系统... 你有没有想过,把你的安卓手机变成一台PC呢?听起来是不是有点酷炫?想象你可以在手机上玩电脑游戏,或者...
手机怎么装安卓11系统,手机安... 你有没有想过,让你的手机也来个“青春焕发”,升级一下系统呢?没错,就是安卓11系统!这个新系统不仅带...
安卓系统如何拼网络,构建高效连... 你有没有想过,你的安卓手机是怎么和网络“谈恋爱”的呢?没错,就是拼网络!今天,就让我带你一探究竟,看...
安卓系统怎么看小说,轻松畅享电... 你有没有发现,手机里装了那么多应用,最离不开的竟然是那个小小的小说阅读器?没错,就是安卓系统上的小说...