mirror of
https://github.com/NohamR/knowledge-kit.git
synced 2026-05-25 12:27:15 +00:00
224 lines
14 KiB
Markdown
224 lines
14 KiB
Markdown
# 享元模式
|
||
|
||
## 定义
|
||
“享元”，顾名思义就是被共享的单元。享元模式的意图是复用对象，节省内存，前提是享元对象是不可变对象。
|
||
|
||
当一个系统中存在大量重复对象的时候，如果这些重复的对象是不可变对象，我们就可以利用享元模式将对象设计成享元，在内存中只保留一份实例，供多处代码引用。这样可以减少内存中对象的数量，起到节省内存的目的。实际上，不仅仅相同对象可以设计成享元，对于相似对象，我们也可以将这些对象中相同的部分（字段）提取出来，设计成享元，让这些大量相似对象引用这些享元。
|
||
|
||
不可变对象”指的是，一旦通过构造函数初始化完成之后，它的状态（对象的成员变量或者属性）就不会再被修改了。所以，不可变对象不能暴露任何 set() 等修改内部状态的方法。之所以要求享元是不可变对象，那是因为它会被多处代码共享使用，避免一处代码对享元进行了修改，影响到其他使用它的代码。
|
||
|
||
## 实现
|
||
享元模式的代码实现非常简单，主要是通过工厂模式，在工厂类中，通过一个 Map 或者 List 来缓存已经创建好的享元对象，以达到复用的目的
|
||
|
||
假设我们在开发一个棋牌游戏（比如象棋）。一个游戏厅中有成千上万个“房间”，每个房间对应一个棋局。棋局要保存每个棋子的数据，比如：棋子类型（将、相、士、炮等）、棋子颜色（红方、黑方）、棋子在棋局中的位置。利用这些数据，我们就能显示一个完整的棋盘给玩家。具体的代码如下所示。其中，ChessPiece 类表示棋子，ChessBoard 类表示一个棋局，里面保存了象棋中 30 个棋子的信息
|
||
```
|
||
public class ChessPiece {//棋子
|
||
private int id;
|
||
private String text;
|
||
private Color color;
|
||
private int positionX;
|
||
private int positionY;
|
||
public ChessPiece(int id, String text, Color color, int positionX, int position) {
|
||
this.id = id;
|
||
this.text = text;
|
||
this.color = color;
|
||
this.positionX = positionX;
|
||
this.positionY = positionX;
|
||
}
|
||
|
||
public static enum Color {
|
||
RED, BLACK
|
||
}
|
||
// ...省略其他属性和getter/setter方法...
|
||
}
|
||
|
||
public class ChessBoard {//棋局
|
||
private Map<Integer, ChessPiece> chessPieces = new HashMap<>();
|
||
public ChessBoard() {
|
||
init();
|
||
}
|
||
private void init() {
|
||
chessPieces.put(1, new ChessPiece(1, "車", ChessPiece.Color.BLACK, 0, 0));
|
||
chessPieces.put(2, new ChessPiece(2,"馬", ChessPiece.Color.BLACK, 0, 1));
|
||
//...省略摆放其他棋子的代码...
|
||
}
|
||
public void move(int chessPieceId, int toPositionX, int toPositionY) {
|
||
//...省略...
|
||
}
|
||
}
|
||
```
|
||
为了记录每个房间当前的棋局情况，我们需要给每个房间都创建一个 ChessBoard 棋局对象。因为游戏大厅中有成千上万的房间（实际上，百万人同时在线的游戏大厅也有很多），那保存这么多棋局对象就会消耗大量的内存。有没有什么办法来节省内存呢？这个时候，享元模式就可以派上用场了。像刚刚的实现方式，在内存中会有大量的相似对象。这些相似对象的 id、text、color 都是相同的，唯独 positionX、positionY 不同。实际上，我们可以将棋子的 id、text、color 属性拆分出来，设计成独立的类，并且作为享元供多个棋盘复用。这样，棋盘只需要记录每个棋子的位置信息就可以了。具体的代码实现如下所示
|
||
```
|
||
// 享元类
|
||
public class ChessPieceUnit {
|
||
private int id;
|
||
private String text;
|
||
private Color color;
|
||
public ChessPieceUnit(int id, String text, Color color) {
|
||
this.id = id;
|
||
this.text = text;
|
||
this.color = color;
|
||
}
|
||
public static enum Color {
|
||
RED, BLACK
|
||
}
|
||
// ...省略其他属性和getter方法...
|
||
}
|
||
|
||
public class ChessPieceUnitFactory {
|
||
private static final Map<Integer, ChessPieceUnit> pieces = new HashMap<>();
|
||
static {
|
||
pieces.put(1, new ChessPieceUnit(1, "車", ChessPieceUnit.Color.BLACK));
|
||
pieces.put(2, new ChessPieceUnit(2,"馬", ChessPieceUnit.Color.BLACK));
|
||
//...省略摆放其他棋子的代码...
|
||
}
|
||
public static ChessPieceUnit getChessPiece(int chessPieceId) {
|
||
return pieces.get(chessPieceId);
|
||
}
|
||
}
|
||
|
||
public class ChessPiece {
|
||
private ChessPieceUnit chessPieceUnit;
|
||
private int positionX;
|
||
private int positionY;
|
||
public ChessPiece(ChessPieceUnit unit, int positionX, int positionY) {
|
||
this.chessPieceUnit = unit;
|
||
this.positionX = positionX;
|
||
this.positionY = positionY;
|
||
}
|
||
// 省略getter、setter方法
|
||
}
|
||
public class ChessBoard {
|
||
private Map<Integer, ChessPiece> chessPieces = new HashMap<>();
|
||
public ChessBoard() {
|
||
init();
|
||
}
|
||
private void init() {
|
||
chessPieces.put(1, new ChessPiece(
|
||
ChessPieceUnitFactory.getChessPiece(1), 0,0));
|
||
chessPieces.put(1, new ChessPiece(
|
||
ChessPieceUnitFactory.getChessPiece(2), 1,0));
|
||
//...省略摆放其他棋子的代码...
|
||
}
|
||
public void move(int chessPieceId, int toPosintionX, int toPositionY) {
|
||
// ...
|
||
}
|
||
}
|
||
```
|
||
|
||
在上面的代码实现中，我们利用工厂类来缓存 ChessPieceUnit 信息（也就是 id、text、color）。通过工厂类获取到的 ChessPieceUnit 就是享元。所有的 ChessBoard 对象共享这 30 个 ChessPieceUnit 对象（因为象棋中只有 30 个棋子）。在使用享元模式之前，记录 1 万个棋局，我们要创建 30 万（30*1 万）个棋子的 ChessPieceUnit 对象。利用享元模式，我们只需要创建 30 个享元对象供所有棋局共享使用即可，大大节省了内存。
|
||
|
||
那享元模式的原理讲完了，我们来总结一下它的代码结构。实际上，它的代码实现非常简单，主要是通过工厂模式，在工厂类中，通过一个 Map 来缓存已经创建过的享元对象，来达到复用的目的。
|
||
|
||
|
||
## 场景
|
||
### 享元模式在 Java Integer 中的应用
|
||
```
|
||
Integer i1 = 56;
|
||
Integer i2 = 56;
|
||
Integer i3 = 129;
|
||
Integer i4 = 129;
|
||
System.out.println(i1 == i2); // true
|
||
System.out.println(i3 == i4); // false
|
||
```
|
||
如果不熟悉 Java 语言，你可能会觉得，i1 和 i2 值都是 56，i3 和 i4 值都是 129，i1 跟 i2 值相等，i3 跟 i4 值相等，所以输出结果应该是两个 true。这样的分析是不对的，主要还是因为你对 Java 语法不熟悉。要正确地分析上面的代码，我们需要弄清楚下面两个问题
|
||
|
||
如何判定两个 Java 对象是否相等（也就代码中的“==”操作符的含义）？什么是自动装箱（Autoboxing）和自动拆箱（Unboxing）？
|
||
|
||
所谓的自动装箱，就是自动将基本数据类型转换为包装器类型。所谓的自动拆箱，也就是自动将包装器类型转化为基本数据类型。具体的代码示例如下所示：
|
||
```
|
||
Integer i = 56; //自动装箱
|
||
int j = i; //自动拆箱
|
||
```
|
||
数值 56 是基本数据类型 int，当赋值给包装器类型（Integer）变量的时候，触发自动装箱操作，创建一个 Integer 类型的对象，并且赋值给变量 i。其底层相当于执行了下面这条语句：
|
||
```
|
||
Integer i = 59；底层执行了：Integer i = Integer.valueOf(59);
|
||
```
|
||
反过来，当把包装器类型的变量 i，赋值给基本数据类型变量 j 的时候，触发自动拆箱操作，将 i 中的数据取出，赋值给 j。其底层相当于执行了下面这条语句：
|
||
```
|
||
int j = i; 底层执行了：int j = i.intValue();
|
||
```
|
||
弄清楚了自动装箱和自动拆箱，我们再来看，如何判定两个对象是否相等？不过，在此之前，我们先要搞清楚，Java 对象在内存中是如何存储的。我们通过下面这个例子来说明一下。
|
||
```
|
||
User a = new User(123, 23); // id=123, age=23
|
||
```
|
||
a 存储的值是 User 对象的内存地址，a 是一个指针，a 的值就是对象的地址值。
|
||
|
||
当我们通过“==”来判定两个对象是否相等的时候，实际上是在判断两个局部变量存储的地址是否相同，换句话说，是在判断两个局部变量是否指向相同的对象。
|
||
|
||
前 4 行赋值语句都会触发自动装箱操作，也就是会创建 Integer 对象并且赋值给 i1、i2、i3、i4 这四个变量。根据刚刚的讲解，i1、i2 尽管存储的数值相同，都是 56，但是指向不同的 Integer 对象，所以通过“==”来判定是否相同的时候，会返回 false。同理，i3==i4 判定语句也会返回 false
|
||
|
||
|
||
不过，上面的分析还是不对，答案并非是两个 false，而是一个 true，一个 false。看到这里，你可能会比较纳闷了。实际上，这正是因为 Integer 用到了享元模式来复用对象，才导致了这样的运行结果。当我们通过自动装箱，也就是调用 valueOf() 来创建 Integer 对象的时候，如果要创建的 Integer 对象的值在 -128 到 127 之间，会从 IntegerCache 类中直接返回，否则才调用 new 方法创建。看代码更加清晰一些，Integer 类的 valueOf() 函数的具体代码如下所示
|
||
```
|
||
public static Integer valueOf(int i) {
|
||
if (i >= IntegerCache.low && i <= IntegerCache.high)
|
||
return IntegerCache.cache[i + (-IntegerCache.low)];
|
||
return new Integer(i);
|
||
}
|
||
```
|
||
实际上，这里的 IntegerCache 相当于，我们上一节课中讲的生成享元对象的工厂类，只不过名字不叫 xxxFactory 而已。我们来看它的具体代码实现。这个类是 Integer 的内部类，你也可以自行查看 JDK 源码
|
||
```
|
||
**
|
||
* Cache to support the object identity semantics of autoboxing for values betw
|
||
* -128 and 127 (inclusive) as required by JLS.
|
||
*
|
||
* The cache is initialized on first usage. The size of the cache
|
||
* may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
|
||
* During VM initialization, java.lang.Integer.IntegerCache.high property
|
||
* may be set and saved in the private system properties in the
|
||
* sun.misc.VM class.
|
||
*/
|
||
private static class IntegerCache {
|
||
static final int low = -128;
|
||
static final int high;
|
||
static final Integer cache[];
|
||
static {
|
||
// high value may be configured by property
|
||
int h = 127;
|
||
String integerCacheHighPropValue =
|
||
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high")
|
||
if (integerCacheHighPropValue != null) {
|
||
try {
|
||
int i = parseInt(integerCacheHighPropValue);
|
||
i = Math.max(i, 127);
|
||
// Maximum array size is Integer.MAX_VALUE
|
||
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
|
||
} catch( NumberFormatException nfe) {
|
||
// If the property cannot be parsed into an int, ignore it.
|
||
}
|
||
}
|
||
high = h;
|
||
cache = new Integer[(high - low) + 1];
|
||
int j = low;
|
||
for(int k = 0; k < cache.length; k++)
|
||
cache[k] = new Integer(j++);
|
||
// range [-128, 127] must be interned (JLS7 5.1.7)
|
||
assert IntegerCache.high >= 127;
|
||
}
|
||
private IntegerCache() {}
|
||
}
|
||
```
|
||
回到问题，56处于-128和127之间，i1 和 i2 会指向相同的享元对象，所以第一个为 true，而129大于127，不会被缓存，所以每次都是一个新的对象，也就是i3和i4指向2个不同的 Integer 对象，所以第二个为 false。
|
||
|
||
|
||
## 对比
|
||
在上面的讲解中，我们多次提到“共享”“缓存”“复用”这些字眼，那它跟单例、缓存、对象池这些概念有什么区别呢？
|
||
|
||
### 享元模式跟单例的区别
|
||
在单例模式中，一个类只能创建一个对象，而在享元模式中，一个类可以创建多个对象，每个对象被多处代码引用共享。实际上，享元模式有点类似于之前讲到的单例的变体：多例。
|
||
|
||
我们前面也多次提到，区别两种设计模式，不能光看代码实现，而是要看设计意图，也就是要解决的问题。尽管从代码实现上来看，享元模式和多例有很多相似之处，但从设计意图上来看，它们是完全不同的。应用享元模式是为了对象复用，节省内存，而应用多例模式是为了限制对象的个数
|
||
|
||
### 享元模式跟缓存的区别
|
||
在享元模式的实现中，我们通过工厂类来“缓存”已经创建好的对象。这里的“缓存”实际上是“存储”的意思，跟我们平时所说的“数据库缓存”“CPU 缓存”“MemCache 缓存”是两回事。我们平时所讲的缓存，主要是为了提高访问效率，而非复用
|
||
|
||
### 享元模式跟对象池的区别
|
||
你可能对连接池、线程池比较熟悉，对对象池比较陌生，所以，这里我简单解释一下对象池。像 C++ 这样的编程语言，内存的管理是由程序员负责的。为了避免频繁地进行对象创建和释放导致内存碎片，我们可以预先申请一片连续的内存空间，也就是这里说的对象池。每次创建对象时，我们从对象池中直接取出一个空闲对象来使用，对象使用完成之后，再放回到对象池中以供后续复用，而非直接释放掉。
|
||
|
||
虽然对象池、连接池、线程池、享元模式都是为了复用，但是，如果我们再细致地抠一抠“复用”这个字眼的话，对象池、连接池、线程池等池化技术中的“复用”和享元模式中的“复用”实际上是不同的概念。
|
||
|
||
池化技术中的“复用”可以理解为“重复使用”，主要目的是节省时间（比如从数据库池中取一个连接，不需要重新创建）。在任意时刻，每一个对象、连接、线程，并不会被多处使用，而是被一个使用者独占，当使用完成之后，放回到池中，再由其他使用者重复利用。享元模式中的“复用”可以理解为“共享使用”，在整个生命周期中，都是被所有使用者共享的，主要目的是节省空间。
|
||
|
||
|