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、思考題

上一講的單例模式和這一講的享元模式都是為了避免重復創建對象，你知道這兩者的區別在哪兒嗎？