文章目录
1. 享元模式概述
享元模式(Flyweight Pattern)是一种结构型设计模式，它通过共享技术有效地支持大量细粒度对象的重用，以减少内存占用和提高性能。享元模式的核心思想是：尽可能共享相似对象，减少创建重复对象，从而节省内存。
享元模式将对象的状态分为内部状态（Intrinsic State）和外部状态（Extrinsic State）：
- 内部状态：存储在享元对象内部，可以被共享的状态，不会随环境改变而改变
- 外部状态：随环境改变而改变的状态，不可共享，由客户端保存和传入享元对象
通过这种方式，相似对象可以被有效复用，只需维护一个对象池，在需要时获取对象即可，而不必每次都创建新对象。
2. 模式结构
享元模式主要包含以下角色：
-
享元工厂(FlyweightFactory): 用于创建和管理享元对象，确保享元对象被正确地共享。当客户端请求一个享元对象时，工厂会检查是否已存在具有相同内部状态的享元对象，如果存在则返回现有对象，否则创建新对象。
-
抽象享元(Flyweight): 所有具体享元类的超类或接口，规定出对象的外部状态和内部状态的接口或实现。
-
具体享元(ConcreteFlyweight): 继承抽象享元并为内部状态增加存储空间，实现共享对象。这些对象必须是可共享的，它所存储的状态必须是内部状态。
-
非共享具体享元(UnsharedConcreteFlyweight): 不需要共享的享元类，通常将多个具体享元对象组合起来，形成复合享元对象。
-
客户端(Client): 维持对享元对象的引用，计算或存储享元对象的外部状态，调用享元对象的操作方法。
3. 内部状态与外部状态
享元模式的核心是区分内部状态(Intrinsic State)和外部状态(Extrinsic State)：
3.1 内部状态
- 定义: 内部状态是存储在享元对象内部，并且不会随环境改变而改变的状态，可以共享。
- 特点:
- 可以被多个对象共享
- 通常在对象创建时确定
- 不会因为对象的使用环境不同而改变
- 一般将不变的、可共享的状态作为内部状态
- 示例: 围棋中棋子的颜色（黑色或白色）
3.2 外部状态
- 定义: 外部状态是随环境改变而改变的、不可以共享的状态。外部状态由客户端保存，在使用享元对象时传入。
- 特点:
- 不可共享
- 随环境变化而变化
- 由客户端保存和传入
- 通常比内部状态更大、更复杂
- 示例: 围棋中棋子的位置（坐标）
3.3 内部状态和外部状态的区分
将对象的状态区分为内部状态和外部状态是享元模式的关键。这种区分是享元模式能够有效减少内存使用的根本原因。
| 特性 | 内部状态 | 外部状态 |
|---|---|---|
| 存储位置 | 享元对象内部 | 客户端 |
| 是否共享 | 可共享 | 不可共享 |
| 变化特性 | 不随环境变化 | 随环境变化 |
| 生命周期 | 与享元对象同寿 | 与特定场景相关 |
| 创建时机 | 对象创建时确定 | 使用对象时指定 |
4. C#代码示例
4.1 简单的文本格式化器示例
下面是一个使用享元模式实现的简单文本格式化器的例子，不同的字符格式可以共享相同的样式：
using System;
using System.Collections.Generic;
// 字符格式 - 享元对象的内部状态
public class CharacterFormat
{
// 内部状态：字体、大小和样式（加粗、斜体等）
public string FontName { get; }
public int FontSize { get; }
public bool IsBold { get; }
public bool IsItalic { get; }
public CharacterFormat(string fontName, int fontSize, bool isBold, bool isItalic)
{
FontName = fontName;
FontSize = fontSize;
IsBold = isBold;
IsItalic = isItalic;
}
// 重写Equals和GetHashCode，便于享元工厂比较对象
public override bool Equals(object obj)
{
if (!(obj is CharacterFormat other)) return false;
return FontName == other.FontName &&
FontSize == other.FontSize &&
IsBold == other.IsBold &&
IsItalic == other.IsItalic;
}
public override int GetHashCode()
{
return HashCode.Combine(FontName, FontSize, IsBold, IsItalic);
}
}
// 字符 - 享元对象
public class Character
{
// 内部状态：字符格式
private readonly CharacterFormat format;
public Character(CharacterFormat format)
{
this.format = format;
}
// 使用外部状态（字符内容和位置）进行操作
public void Display(char content, int x, int y)
{
Console.WriteLine($"字符: {content}, 位置: ({x},{y}), 字体: {format.FontName}, " +
$"大小: {format.FontSize}, 粗体: {format.IsBold}, 斜体: {format.IsItalic}");
}
}
// 享元工厂 - 管理字符对象池
public class CharacterFactory
{
// 存储已创建的享元对象
private readonly Dictionary<CharacterFormat, Character> characters = new Dictionary<CharacterFormat, Character>();
// 获取享元对象，如果不存在则创建
public Character GetCharacter(CharacterFormat format)
{
// 查找是否已存在具有相同格式的字符对象
if (!characters.TryGetValue(format, out var character))
{
// 不存在则创建新对象
character = new Character(format);
characters.Add(format, character);
Console.WriteLine($"创建新字符对象，字体: {format.FontName}, 大小: {format.FontSize}");
}
else
{
Console.WriteLine($"复用现有字符对象，字体: {format.FontName}, 大小: {format.FontSize}");
}
return character;
}
// 获取已创建的享元对象数量
public int GetCharacterCount()
{
return characters.Count;
}
}
// 客户端代码
public class TextEditor
{
public static void Main()
{
CharacterFactory factory = new CharacterFactory();
// 创建一些常用的文本格式
CharacterFormat normalFormat = new CharacterFormat("Arial", 12, false, false);
CharacterFormat boldFormat = new CharacterFormat("Arial", 12, true, false);
CharacterFormat italicFormat = new CharacterFormat("Arial", 12, false, true);
CharacterFormat titleFormat = new CharacterFormat("Times New Roman", 16, true, false);
// 模拟在文本编辑器中输入文本
// 注意：相同格式的字符会共享同一个Character对象，只是外部状态(字符内容、位置)不同
// 标题文本: "Hello, Flyweight Pattern!"
Character titleChar = factory.GetCharacter(titleFormat);
string title = "Hello, Flyweight Pattern!";
for (int i = 0; i < title.Length; i++)
{
// 外部状态：字符内容和位置
titleChar.Display(title[i], i * 10, 0);
}
// 普通文本
Character normalChar = factory.GetCharacter(normalFormat);
string normalText = "This is a simple text editor example.";
for (int i = 0; i < normalText.Length; i++)
{
normalChar.Display(normalText[i], i * 10, 20);
}
// 加粗文本
Character boldChar = factory.GetCharacter(boldFormat);
string boldText = "Important!";
for (int i = 0; i < boldText.Length; i++)
{
boldChar.Display(boldText[i], i * 10, 40);
}
// 斜体文本
Character italicChar = factory.GetCharacter(italicFormat);
string italicText = "Emphasized text.";
for (int i = 0; i < italicText.Length; i++)
{
italicChar.Display(italicText[i], i * 10, 60);
}
// 复用已有格式
string moreNormalText = "More normal text here.";
for (int i = 0; i < moreNormalText.Length; i++)
{
normalChar.Display(moreNormalText[i], i * 10, 80);
}
// 显示创建的享元对象数量
Console.WriteLine($"\n总共创建的字符格式对象数量: {factory.GetCharacterCount()}");
Console.WriteLine("如果不使用享元模式，需要创建的对象数量: " +
(title.Length + normalText.Length + boldText.Length +
italicText.Length + moreNormalText.Length));
}
}
4.2 游戏中的图形渲染示例
下面是一个使用享元模式优化游戏中大量相似图形对象渲染的示例：
using System;
using System.Collections.Generic;
using System.Drawing;
// 树木类型（内部状态）- 共享部分
public class TreeType
{
// 内部状态：树的名称、贴图、模型等
public string Name { get; }
public string Texture { get; }
public string Model { get; }
public Color Color { get; }
public TreeType(string name, string texture, string model, Color color)
{
Name = name;
Texture = texture;
Model = model;
Color = color;
// 模拟加载贴图和3D模型的操作（在实际应用中，这可能是一个耗时的操作）
Console.WriteLine($"加载树木类型: {name}, 贴图: {texture}, 模型: {model}, 颜色: {color}");
}
// 绘制树木，接收外部状态（坐标和其他动态数据）
public void Draw(int x, int y, float scale, float rotation)
{
Console.WriteLine($"在位置 ({x},{y}) 绘制 {Name} 树, 缩放: {scale}, 旋转: {rotation}度, " +
$"贴图: {Texture}, 模型: {Model}, 颜色: {Color}");
// 实际的渲染代码在这里...
}
}
// 树木工厂 - 享元工厂
public class TreeFactory
{
private Dictionary<string, TreeType> treeTypes = new Dictionary<string, TreeType>();
// 获取或创建树木类型
public TreeType GetTreeType(string name, string texture, string model, Color color)
{
// 为简化，使用name作为键
if (!treeTypes.TryGetValue(name, out var treeType))
{
treeType = new TreeType(name, texture, model, color);
treeTypes.Add(name, treeType);
}
return treeType;
}
public int GetTreeTypeCount()
{
return treeTypes.Count;
}
}
// 具体的树木实例（组合了TreeType和位置信息）
public class Tree
{
// 引用享元对象
private TreeType type;
// 外部状态：位置、缩放、旋转等
private int x;
private int y;
private float scale;
private float rotation;
public Tree(TreeType type, int x, int y, float scale, float rotation)
{
this.type = type;
this.x = x;
this.y = y;
this.scale = scale;
this.rotation = rotation;
}
public void Draw()
{
// 将外部状态传递给享元对象
type.Draw(x, y, scale, rotation);
}
}
// 森林 - 管理多个树木实例
public class Forest
{
private List<Tree> trees = new List<Tree>();
private TreeFactory factory = new TreeFactory();
// 添加一棵树
public void PlantTree(string name, string texture, string model, Color color,
int x, int y, float scale, float rotation)
{
// 通过工厂获取享元对象
TreeType treeType = factory.GetTreeType(name, texture, model, color);
// 创建树木实例，组合享元对象和外部状态
Tree tree = new Tree(treeType, x, y, scale, rotation);
trees.Add(tree);
}
// 绘制所有树木
public void Draw()
{
foreach (var tree in trees)
{
tree.Draw();
}
}
// 获取统计信息
public void PrintStats()
{
Console.WriteLine($"\n森林统计:");
Console.WriteLine($"实际树木数量: {trees.Count}");
Console.WriteLine($"树木类型数量: {factory.GetTreeTypeCount()}");
Console.WriteLine($"内存节省: 约 {trees.Count - factory.GetTreeTypeCount()} 个树木对象的贴图和模型数据");
}
}
// 客户端代码
public class GameDemo
{
public static void Main()
{
// 创建森林
Forest forest = new Forest();
// 种植不同类型的树木，随机分布在森林中
Random rand = new Random();
// 种植100棵松树
for (int i = 0; i < 100; i++)
{
forest.PlantTree(
"松树",
"pine_texture.png",
"pine_model.obj",
Color.DarkGreen,
rand.Next(0, 1000), // x坐标
rand.Next(0, 1000), // y坐标
0.8f + (float)rand.NextDouble() * 0.4f, // 随机缩放
(float)rand.NextDouble() * 360 // 随机旋转
);
}
// 种植50棵橡树
for (int i = 0; i < 50; i++)
{
forest.PlantTree(
"橡树",
"oak_texture.png",
"oak_model.obj",
Color.Green,
rand.Next(0, 1000),
rand.Next(0, 1000),
0.9f + (float)rand.NextDouble() * 0.3f,
(float)rand.NextDouble() * 360
);
}
// 种植30棵枫树
for (int i = 0; i < 30; i++)
{
forest.PlantTree(
"枫树",
"maple_texture.png",
"maple_model.obj",
Color.OrangeRed,
rand.Next(0, 1000),
rand.Next(0, 1000),
0.7f + (float)rand.NextDouble() * 0.5f,
(float)rand.NextDouble() * 360
);
}
// 绘制森林（仅绘制前5棵树，避免输出过多）
Console.WriteLine("\n绘制森林（仅显示前5棵树）:");
for (int i = 0; i < 5 && i < forest.trees.Count; i++)
{
forest.trees[i].Draw();
}
Console.WriteLine("...");
// 显示统计信息
forest.PrintStats();
}
}
5. 实际应用场景
5.1 文本编辑器
在文本编辑器中，文本中的每个字符都是一个对象，包含字符的内容、字体、大小、样式等信息。如果为每个字符创建一个完整的对象，对于一个包含大量文本的文档来说，内存消耗将会非常大。
使用享元模式，可以将字符的样式信息（字体、大小、颜色等）作为内部状态共享，将字符的内容和位置作为外部状态。这样，具有相同样式的字符可以共享同一个字符样式对象，大大减少内存使用。
5.2 图形绘制程序
在图形绘制程序中，可能需要绘制大量相似的图形元素，如线条、矩形、圆形等。这些元素的形状、颜色等信息可以作为内部状态共享，而位置、大小等信息作为外部状态。
例如，一个CAD程序中可能有成千上万个圆形，但这些圆形可能只有少数几种颜色和线型。使用享元模式，可以创建少量的圆形对象（每种颜色和线型组合一个），然后通过传入不同的位置和大小参数来绘制不同的圆形实例。
5.3 游戏开发
在游戏开发中，可能需要渲染大量相似的对象，如树木、草地、敌人等。使用享元模式可以共享这些对象的贴图、模型等资源，而位置、朝向等信息则作为外部状态。
上面的代码示例展示了如何在游戏中使用享元模式优化树木的渲染。在一个森林场景中，可能有成千上万棵树，但树的类型可能只有几种。通过共享树木的贴图和模型等信息，可以大大减少内存使用和提高性能。
5.4 网页浏览器
在网页浏览器中，每个字符都需要一个对象来表示其内容和样式。使用享元模式，浏览器可以共享相同样式的字符，减少内存消耗。
5.5 棋盘游戏
在围棋、象棋等棋盘游戏中，棋子的颜色（黑或白）可以作为内部状态，而棋子的位置作为外部状态。这样，只需要两个棋子对象（黑和白）就可以表示棋盘上的所有棋子。
6. 享元模式的实现步骤
实现享元模式通常遵循以下步骤：
-
识别内部状态和外部状态：
- 内部状态：可共享的、不可变的状态
- 外部状态：不可共享的、会随环境变化的状态
-
设计享元接口：
- 定义接受外部状态的方法
-
实现具体享元类：
- 实现享元接口
- 存储内部状态
- 提供接受外部状态的方法
-
创建享元工厂：
- 管理享元对象池
- 提供获取享元对象的方法
- 确保享元对象被正确共享
-
调整客户端代码：
- 计算或存储享元的外部状态
- 通过享元工厂获取享元对象
- 将外部状态传递给享元对象
7. 享元模式的优缺点
7.1 优点
-
减少对象数量：通过共享相似对象，大大减少了系统中对象的数量。
-
降低内存占用：共享对象的内部状态，避免了重复创建相同数据，减少了内存消耗。
-
提高性能：减少对象创建和垃圾回收的次数，提高了系统性能。
-
集中管理共享对象：通过享元工厂集中管理共享对象，便于维护和控制。
7.2 缺点
-
增加复杂性：需要区分内部状态和外部状态，增加了系统设计的复杂性。
-
外部状态传递的开销：每次操作都需要将外部状态传递给享元对象，可能带来一定的运行时开销。
-
线程安全问题：在多线程环境中，需要确保享元工厂的线程安全，这可能增加复杂性或降低性能。
-
不适用于对象状态经常变化的场景：如果对象的大部分状态都是外部状态，享元模式的优势就不明显了。
8. 享元模式与其他设计模式的比较
| 设计模式 | 主要目的 | 与享元模式的关系 |
|---|---|---|
| 单例模式 | 确保一个类只有一个实例 | 享元模式可以看作是对"多例"模式的一种扩展，它允许有多个共享的实例 |
| 工厂模式 | 封装对象的创建过程 | 享元工厂是工厂模式的一种特殊应用，用于创建和管理享元对象 |
| 组合模式 | 将对象组合成树形结构 | 享元模式常与组合模式结合使用，优化组合对象中重复元素的存储 |
| 代理模式 | 控制对对象的访问 | 虽然两者都使用一个对象代表另一个对象，但目的不同：享元是为了共享相似对象，代理是为了控制访问 |
9. 享元模式在C#中的最佳实践
9.1 使用弱引用缓存
在C#中，可以使用WeakReference或ConditionalWeakTable来存储享元对象，以便在内存压力大时允许垃圾回收器回收不再使用的享元对象：
public class FlyweightFactory
{
// 使用弱引用字典存储享元对象
private readonly ConditionalWeakTable<string, WeakReference<Flyweight>> flyweights =
new ConditionalWeakTable<string, WeakReference<Flyweight>>();
public Flyweight GetFlyweight(string key, Func<Flyweight> createFunc)
{
if (flyweights.TryGetValue(key, out var weakRef) &&
weakRef.TryGetTarget(out var flyweight))
{
return flyweight;
}
var newFlyweight = createFunc();
flyweights.AddOrUpdate(key, new WeakReference<Flyweight>(newFlyweight));
return newFlyweight;
}
}
9.2 使用不可变对象作为享元
享元对象的内部状态应该是不可变的，这样可以确保它们可以安全地共享。在C#中，可以通过使用只读属性或不可变类型来实现这一点：
// 不可变的享元对象
public class ImmutableFlyweight
{
// 只读属性，创建后不能修改
public string Property1 { get; }
public int Property2 { get; }
public ImmutableFlyweight(string property1, int property2)
{
Property1 = property1;
Property2 = property2;
}
public void Operation(string externalState)
{
// 使用内部状态和外部状态执行操作
Console.WriteLine($"内部状态：{Property1}, {Property2}，外部状态：{externalState}");
}
}
9.3 线程安全的享元工厂
在多线程环境中，享元工厂需要是线程安全的，以避免创建重复的享元对象：
public class ThreadSafeFlyweightFactory
{
// 线程安全的字典
private readonly ConcurrentDictionary<string, Flyweight> flyweights =
new ConcurrentDictionary<string, Flyweight>();
public Flyweight GetFlyweight(string key)
{
// 如果不存在，则创建新的享元对象
return flyweights.GetOrAdd(key, k => new ConcreteFlyweight(k));
}
}
10. 总结
享元模式是一种有效的内存优化技术，特别适用于需要创建大量相似对象的场景。通过区分内部状态和外部状态，享元模式允许共享相似对象，从而减少内存占用和提高性能。
享元模式的核心在于：
- 将对象状态分为内部状态（可共享）和外部状态（不可共享）
- 使用享元工厂管理共享对象池
- 通过传递外部状态来定制享元对象的行为
尽管享元模式可能增加系统的复杂性，但在适当的场景下，它能够带来显著的性能提升和内存优化。特别是在处理大量细粒度对象的应用中，如文本编辑器、图形处理程序和游戏开发等领域，享元模式的优势更加明显。
在实践中，应该根据实际需求谨慎评估使用享元模式的必要性，并注意内部状态和外部状态的合理划分，以获得最佳的优化效果。
学习资源
- Design Patterns: Elements of Reusable Object-Oriented Software - GoF经典著作，享元模式的原始定义来源
- Head First Design Patterns - 通过生动的例子讲解设计模式，包括享元模式
- Refactoring.Guru - Flyweight Pattern - 提供了详细的享元模式解释和示例
- C# Design Pattern Essentials - 专注于C#中设计模式的实现
- Game Programming Patterns - 特别介绍了享元模式在游戏开发中的应用
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
