了解享元模式

如果大家觉得文章有错误内容，欢迎留言或者私信讨论~

原理与实现

  所谓“享元”模式，顾名思义就是被共享的对象。享元模式的意图是复用对象，节省内存，前提是对象是不可变对象（不可变的对象是指当对象创造出来之后，它的状态注入成员变量或者属性就不会再修改）。
  具体来讲，当系统中存在大量的重复对象时，且对象是不可变对象，我们就可以将这些对象根据享元模式将这些对象在内存中只保留一份，供多处代码引用。并且如果内存中存在大量相似的对象，也可以把它们当中重复的部分提取出来，采取同样的策略去引用这些享元。
  接下来，我们通过一个简单的例子解释一下享元模式：

  假设我们开发一个棋牌游戏，例如象棋。一个游戏厅中有成千上万个“房间”，每个房间对应一个棋局。棋局要保存每个棋子的数据，比如：棋子类型（将、相、士、炮等）、棋子颜色（红方、黑方）、棋子在棋局中的位置。利用这些数据，我们就能显示一个完整的棋
盘给玩家。具体的代码如下所示。其中，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 positi
		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) {
		//...省略...
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

  为了记录每个房间当前的棋局情况，我们需要给每个房间都创建一个 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 toPositionX, int toPositionY) {
		//...省略...
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

  从上面的代码中，我们利用工厂来缓存 ChessPieceUnit 的信息，也就是说我们把 30 个旗子信息都提前加载到内存中去供棋局共享。在使用享元模式之前，记录 1 万个棋局，我们要创建 30 万（30*1 万）个棋子的 ChessPieceUnit 对象。利用享元模式，我们只需要创建 30 个享元对象供所有棋局共享使用即可，大大节省了内存。

  享元模式的原理讲完了，我们来总结一下它的代码结构，实际上，它的代码实现非常简单，主要是通过工厂模式，在工厂类中，通过一个 Map 来缓存已经创建过的享元对象，来达到复用的目的。

享元模式 vs 单例、缓存、对象池

  在上面的讲解中，我们多次提到“共享”“缓存”“复用”这些字眼，那它跟单例、缓存、对象池这些概念有什么区别呢？我们来简单对比一下

• 先来看一下享元模式与单例的区别

  在单例模式中，一个类只能创建一个对象，但是在享元模式中，一个类可以创造多个，享元的根绝更类似于单例的变体：多例。
  我们在使用设计模式的时候，不能光看代码实现，而是要看设计意图，也就是要解决的问题。尽管从代码实现上来看，享元模式和多例有很多相似之处，但从设计意图上来看，它们是完全不同的。应用享元模式是为了对象复用，节省内存，而应用多例模式是为了限制对象的个数。

• 享元模式与缓存的区别

  虽然享元通过工厂将对象提前加载到内存中去。但是它跟缓存的意图是有区分的：缓存的意图是在提高访问效率，而享元则是为节省内存，复用对象。

• 最后我们来看一下享元模式和对象池的区别

  对象池、连接池（比如数据库连接池）、线程池等也是为了复用，那它们跟享元模式有什么区别呢？虽然对象池、连接池、线程池、享元模式都是为了复用，但是，如果我们再细致地抠一抠“复用”这个字眼的话，对象池、连接池、线程池等池化技术中的“复用”和享元模式中的“复用”实际上是不同的概念。

  池化技术中的“复用”可以理解为“重复使用”，主要目的是节省时间（比如从数据库池中取一个连接，不需要重新创建）。在任意时刻，每一个对象、连接、线程，并不会被多处使用，而是被一个使用者独占，当使用完成之后，放回到池中，再由其他使用者重复利用。享元模式中的“复用”可以理解为“共享使用”，在整个生命周期中，都是被所有使用者共享的，主要目的是节省空间。

享元在 Java 中的应用

  享元模式用一句话总结就是，通过复用对象，以达到节省内存的目的。如果你熟悉 Java 语言你就会知道享元有个我们天天接触的类有涉及。

Integer

  我们先来看下面这样一段代码。你可以先思考下，这段代码会输出什么样的结果。

Integer i1 = 56;
Integer i2 = 56;
Integer i3 = 129;
Integer i4 = 129;
System.out.println(i1 == i2);
System.out.println(i3 == i4);
1
2
3
4
5
6

  在这个例子中，你可能需要知道两个前提知识：

1. Java 为基本数据类型提供了对应的包装器类型

  所谓的自动装箱，就是自动将基本数据类型转换为包装器类型。所谓的自动拆箱，也就是自动将包装器类型转化为基本数据类型。具体的代码示例如下所示：

Integer i = 56; //自动装箱
int j = i; //自动拆箱
1
2

  数值 56 是基本数据类型 int，当赋值给包装器类型（Integer）变量的时候，触发自动装箱操作，创建一个 Integer 类型的对象，并且赋值给变量 i。其底层相当于执行了下面这条语句：

Integer i = 59；
底层执行了：Integer i = Integer.valueOf(59);
1
2

  反过来，当把包装器类型的变量 i，赋值给基本数据类型变量 j 的时候，触发自动拆箱操作，将 i 中的数据取出，赋值给 j。其底层相当于执行了下面这条语句：

int j = i; 
底层执行了：int j = i.intValue();
1
2

  弄清楚了自动装箱和自动拆箱，我们再来看，如何判定两个对象是否相等？不过，在此之前，我们先要搞清楚，Java 对象在内存中是如何存储的。我们通过下面这个例子来说明一下：

User a = new User(123, 23); // id=123, age=23
1

  针对这条语句，我画了一张内存存储结构图，如下所示。a 存储的值是 User 对象的内存地址，在图中就表现为 a 指向 User 对象：

  当我们通过 “==” 来判断两个对象是否相同的时候，实际上是在判断两个局部变量存储的地址是否相同，换句话说，是在判断两个局部变量是否指向相同的对象。

  了解了 Java 这几个语法之后，重新看一下开头的那段代码：

Integer i1 = 56;
Integer i2 = 56;
Integer i3 = 129;
Integer i4 = 129;
System.out.println(i1 == i2);
System.out.println(i3 == i4);
1
2
3
4
5
6

  前 4 行赋值语句都会触发自动装箱操作，也就是会创建 Integer 对象并且赋值给 i1、i2、i3、i4 这四个变量。根据刚刚的讲解，i1、i2 尽管存储的数值相同，都是 56，但是指向不同的 Integer 对象，所以通过“ == ” 来判定是否相同的时候，会返回 false。同理，i3==i4 判定语句也会返回 false。

  不过，上面的分析还是不对，答案并非是两个 false，而是一个 true，一个 false。其实，当我们通过自动装箱，也就是调用 valueOf() 来创建 Integer 对象的时候，如果要创建的 Integer 对象的值在 -128 到 127 之间，会从 IntegerCache 类中直接返回，否则才调用 new 方法创建。 你可以看以下具体代码：

public static Integer valueOf(int i) {
	if (i >= IntegerCache.low && i <= IntegerCache.high)
		return IntegerCache.cache[i + (-IntegerCache.low)];
	return new Integer(i);
}
1
2
3
4
5

  实际上，这里的 IntegerCache 相当于我们上面讲的生成享元对象的工厂类，具体你可以看 Java 的代码：

/**
* 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=} 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 {
		//....这里	
	}
	
	private IntegerCache() {}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

  为什么 IntegerCache 只缓存 -128 到 127 之间的整型值呢？

  在 IntegerCache 的代码实现中，当这个类被加载的时候，缓存的享元对象会被集中一次性创建好。毕竟整型值太多了，我们不可能在 IntegerCache 类中预先创建好所有的整型值，这样既占用太多内存，也使得加载 IntegerCache 类的时间过长。所以，我们只能选择缓存对于大部分应用来说最常用的整型值，也就是一个字节的大小（-128 到 127 之间的数
据）。

  实际上，JDK 也提供了方法来让我们可以自定义缓存的最大值，有下面两种方式。如果你通过分析应用的 JVM 内存占用情况，发现 -128 到 255 之间的数据占用的内存比较多，你就可以用如下方式，将缓存的最大值从 127 调整到 255。不过，这里注意一下，JDK 并没有提供设置最小值的方法。

//方法一：
-Djava.lang.Integer.IntegerCache.high=255

//方法二：
-XX:AutoBoxCacheMax=255
1
2
3
4
5

  那么回到上面的问题，你现在是否就清晰很多了？因为 56 处于 -128 和 127 之间，i1 和 i2 会指向相同的享元对象，所以 i1i2 返回 true。而 129 大于 127，并不会被缓存，每次都会创建一个全新的对象，也就是说，i3 和 i4 指向不同的 Integer 对象，所以 i3i4 返回 false。