结构型-享元模式

享元模式（Flyweight Design Pattern）

定义

所谓“享元”，顾名思义就是被共享的单元。享元模式的意图是复用对象，节省内存，前提
是享元对象是不可变对象。

实现方式

当一个系统中存在大量重复对象的时候，如果这些重复的对象是不可变对象，我
们就可以利用享元模式将对象设计成享元，在内存中只保留一份实例，供多处代码引用。这
样可以减少内存中对象的数量，起到节省内存的目的。

享元VS单例、缓存、对象池

单例

在单例模式中，一个类只能创建一个对象，而在享元模式中，一个类可以创建多个对象，每
个对象被多处代码引用共享。

缓存

在享元模式的实现中，我们通过工厂类来“缓存”已经创建好的对象。这里的“缓存”实际
上是“存储”的意思，跟我们平时所说的“数据库缓存”“CPU 缓存”“MemCache 缓
存”是两回事。我们平时所讲的缓存，主要是为了提高访问效率，而非复用。

对象池

虽然对象池、连接池、线程池、享元模式都是为了复用，但是，如果我们再细致地抠一
抠“复用”这个字眼的话，对象池、连接池、线程池等池化技术中的“复用”和享元模式中
的“复用”实际上是不同的概念。

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

go源码实现

package flyweight

var units = map[int]*ChessPieceUnit{
	1: {
		ID:    1,
		Name:  "車",
		Color: "red",
	},
	2: {
		ID:    2,
		Name:  "炮",
		Color: "red",
	},
	// ... 其他棋子
}

// ChessPieceUnit 棋子享元
type ChessPieceUnit struct {
	ID    uint
	Name  string
	Color string
}

// NewChessPieceUnit 工厂
func NewChessPieceUnit(id int) *ChessPieceUnit {
	return units[id]
}

// ChessPiece 棋子
type ChessPiece struct {
	Unit *ChessPieceUnit
	X    int
	Y    int
}

// ChessBoard 棋局
type ChessBoard struct {
	chessPieces map[int]*ChessPiece
}

// NewChessBoard 初始化棋盘
func NewChessBoard() *ChessBoard {
	board := &ChessBoard{chessPieces: map[int]*ChessPiece{}}
	for id := range units {
		board.chessPieces[id] = &ChessPiece{
			Unit: NewChessPieceUnit(id),
			X:    0,
			Y:    0,
		}
	}
	return board
}

// Move 移动棋子
func (c *ChessBoard) Move(id, x, y int) {
	c.chessPieces[id].X = x
	c.chessPieces[id].Y = y
}