享元模式（Flyweight Pattern）详解
一、享元模式简介
享元模式（Flyweight Pattern） 是一种 结构型设计模式（对象结构型模式），它通过共享技术实现相同或相似对象的重用，以减少内存占用和提高性能。具体来说，就是将一些细粒度的对象集中起来，使得这些对象可以互相共享。
又称为轻量级模式，要求能够被共享的对象必须是细粒度对象
运用共享技术有效地支持大量细粒度对象的复用。
简单来说：
“如果你有一堆相似的对象，为什么不让他们共享数据，从而节省内存呢？”
字符享元对象示意图
享元模式：通过共享技术实现相同或相似对象的重用
享元池(Flyweight Pool)：存储共享实例对象的地方
原理
- 将具有相同内部状态的对象存储在享元池中，享元池中的对象是可以实现共享的
- 需要的时候将对象从享元池中取出，即可实现对象的复用
- 通过向取出的对象注入不同的外部状态，可以得到一系列相似的对象，而这些对象在内存中实际上只存储一份
享元模式包含以下4个角色：
Flyweight（抽象享元类）
ConcreteFlyweight（具体享元类）
UnsharedConcreteFlyweight（非共享具体享元类）
FlyweightFactory（享元工厂类）
二、解决的问题类型
享元模式主要用于解决以下问题：
- 大量小对象导致内存消耗过大：当你的应用程序需要创建大量相似的小对象时，直接创建这些对象会导致内存使用过高。
- 提升性能：通过共享相同的对象实例来减少对象创建的数量，进而减少垃圾回收的压力，提高系统性能。
- 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中
- 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，在需要多次重复使用享元对象时才值得使用享元模式
三、使用场景
| 场景 | 示例 |
|---|---|
| 字符串池 | Java 中的 String.intern() 方法 |
| 缓存管理 | 如缓存数据库查询结果 |
| 文档处理 | 文本编辑器中的字符样式管理 |
| 游戏开发 | 游戏中大量的相同纹理、模型等资源 |
四、核心概念
1. 内部状态 vs 外部状态
- 内部状态：存储在享元对象内部，可以在多个对象之间共享的部分，且不会随环境改变而改变的状态，通常是不变的数据。（例如：字符的内容）
- 外部状态：不能被共享的部分，是随环境变化而变化的数据。享元对象的外部状态通常由客户端保存，并在享元对象被创建之后，需要使用的时候再传入到享元对象内部。一个外部状态与另一个外部状态之间是相互独立的（例如：字符的颜色和大小）
享元模式的核心思想就是分离对象的内部状态和外部状态，让内部状态可以共享，而外部状态则由客户端负责维护。
五、代码案例（Java）
我们以一个简单的文本编辑器为例，展示如何利用享元模式来优化字体样式的管理。
1. 定义享元接口
interface CharacterStyle {
void display(char character);
}
2. 创建具体的享元类
class CharacterStyleImpl implements CharacterStyle {
private final String fontName;
private final int fontSize;
public CharacterStyleImpl(String fontName, int fontSize) {
this.fontName = fontName;
this.fontSize = fontSize;
}
@Override
public void display(char character) {
System.out.println(character + " in " + fontName + ", size: " + fontSize);
}
}
3. 创建享元工厂
class CharacterStyleFactory {
private static final Map<String, CharacterStyle> styles = new HashMap<>();
public static CharacterStyle getStyle(String fontName, int fontSize) {
String key = fontName + "-" + fontSize;
if (!styles.containsKey(key)) {
styles.put(key, new CharacterStyleImpl(fontName, fontSize));
}
return styles.get(key);
}
}
4. 使用享元模式
public class Client {
public static void main(String[] args) {
// 获取样式
CharacterStyle style1 = CharacterStyleFactory.getStyle("Arial", 12);
CharacterStyle style2 = CharacterStyleFactory.getStyle("Arial", 12);
// 显示字符
style1.display('A'); // 输出: A in Arial, size: 12
style2.display('B'); // 输出: B in Arial, size: 12
// 验证是否为同一实例
System.out.println(style1 == style_Statics); // 输出: true
}
}
典型代码(c++)
典型的抽象享元类代码
abstract class Flyweight
{
public abstract void Operation(string extrinsicState);
}
典型的具体享元类代码
class ConcreteFlyweight : Flyweight
{
//内部状态intrinsicState作为成员变量，同一个享元对象其内部状态是一致的
private string intrinsicState;
public ConcreteFlyweight(string intrinsicState)
{
this.intrinsicState = intrinsicState;
}
//外部状态extrinsicState在使用时由外部设置，不保存在享元对象中，即使是同一个对象，在每一次调用时可以传入不同的外部状态
public override void Operation(string extrinsicState)
{
//实现业务方法
}
}
典型的非共享具体享元类代码
class UnsharedConcreteFlyweight : Flyweight
{
public override void Operation(string extrinsicState)
{
//实现业务方法
}
}
典型的享元工厂类代码
using System.Collections;
class FlyweightFactory
{
//定义一个Hashtable用于存储享元对象，实现享元池
private Hashtable flyweights = new Hashtable();
public Flyweight GetFlyweight(string key)
{
//如果对象存在，则直接从享元池获取
if (flyweights.ContainsKey(key))
{
return (Flyweight)flyweights[key];
}
//如果对象不存在，先创建一个新的对象添加到享元池中，然后返回
else
{
Flyweight fw = new ConcreteFlyweight("state");
flyweights.Add(key,fw);
return fw;
}
}
}
其他案例
- 某软件公司要开发一个围棋软件，其界面效果如下图所示
该软件公司开发人员通过对围棋软件进行分析发现，在图中，围棋棋盘中包含大量的黑子和白子，它们的形状、大小都一模一样，只是出现的位置不同而已。如果将每一个棋子都作为一个独立的对象存储在内存中，将导致该围棋软件在运行时所需内存空间较大，如何降低运行代价、提高系统性能是需要解决的一个问题。为了解决该问题，现使用享元模式来设计该围棋软件的棋子对象。
如何让相同的黑子或者白子能够多次重复显示但位于一个棋盘的不同地方？
解决方案：将棋子的位置定义为棋子的一个外部状态，在需要时再进行设置
（引入外部状态之后的围棋棋子结构图）
//Coordinates.cs
namespace FlyweightSample
{
class Coordinates
{
private int x;
private int y;
public Coordinates(int x, int y)
{
this.x = x;
this.y = y;
}
public int X
{
get { return x; }
set { x = value; }
}
public int Y
{
get { return y; }
set { y = value; }
}
}
}
//IgoChessman.cs
using System;
namespace FlyweightSample
{
abstract class IgoChessman
{
public abstract string GetColor();
public void Display(Coordinates coord)
{
Console.WriteLine("棋子颜色：{0}，棋子位置：{1}，{2}", this.GetColor(),coord.X,coord.Y);
}
}
}
- 共享网络设备（无外部状态）
很多网络设备都是支持共享的，如交换机、集线器等，多台终端计算机可以连接同一台网络设备，并通过该网络设备进行数据转发，如图所示，现用享元模式模拟共享网络设备的设计原理
- 共享网络设备（有外部状态）
虽然网络设备可以共享，但是分配给每一个终端计算机的端口(Port)是不同的，因此多台计算机虽然可以共享同一个网络设备，但必须使用不同的端口。我们可以将端口从网络设备中抽取出来作为外部状态，需要时再进行设置
六、优缺点分析
| 优点 | 描述 |
|---|---|
| ✅ 节省内存 | 减少了大量相似对象的创建，降低了内存使用 |
| ✅ 提高性能 | 减少了对象创建的时间开销 |
| ✅ 支持大规模并发 | 在多线程环境中也能很好地工作 |
| 其他 | 外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享 |
| 缺点 | 描述 |
|---|---|
| ❌ 复杂性增加 | 分离内部状态和外部状态增加了设计复杂度 |
| ❌ 可能影响可读性 | 对于不熟悉该模式的人来说，理解代码逻辑可能会变得困难 |
| ❌ 不适合频繁变化的状态 | 如果大部分状态都是外部状态，则享元模式的优势无法体现。为了使对象可以共享，享元模式需要将享元对象的部分状态外部化，而读取外部状态将使得运行时间变长 |
七、与其他模式对比（补充）
| 模式名称 | 目标 |
|---|---|
| 单例模式 | 确保某个类只有一个实例，并提供全局访问点 |
| 原型模式 | 通过克隆已有对象来创建新对象，强调复用 |
| 享元模式 | 通过共享技术减少相似对象的创建，节约内存 |
八、最终小结
享元模式是一种非常有效的设计模式，特别适合那些：
- 存在大量相似对象的应用场景；
- 希望减少内存使用并提高性能的情况；
- 可以明确区分内部状态和外部状态的对象。
掌握享元模式可以帮助你在处理大量相似对象时更加高效地管理内存资源，特别是在游戏开发、文档处理等领域。
📌 一句话总结：
享元模式就像是一个“共享池”，把那些可以共享的部分放在一起，避免重复创建，从而达到节省内存的目的。
✅ 推荐使用方式：
- 当你发现你的应用中有许多相似但独立的对象时，考虑使用享元模式。
- 注意合理划分内部状态和外部状态，确保设计简洁且易于维护。
九、扩展
单纯享元模式和复合享元模式
单纯享元模式：
所有的具体享元类都是可以共享的，不存在非共享具体享元类
复合享元模式：
将一些单纯享元对象使用组合模式加以组合
如果希望为多个内部状态不同的享元对象设置相同的外部状态，可以考虑使用复合享元模式
部分内容由AI大模型生成，注意识别！