# 前言
享元模式是一种**结构型设计模式**，其核心目标是**通过共享对象来高效支持大量细粒度对象，从而显著减少内存消耗**，我称之为**性能优化型设计模式**。

我们可以把它想象成一个高效的“资源池”。当系统需要创建大量相似对象时，如果每个对象都独立存储所有数据，内存会迅速耗尽。

享元模式的做法是：**将对象中不变、可共享的部分（内在状态）抽取出来，单独存放、全局复用**；而那些变化的、个性化的部分（外在状态）则保留在对象内部或由客户端在使用时传入。

这样，成千上万的对象可以共享少量的“享元”对象，就像成千上万的玩家可以共享同一套“恐怖分子”或“反恐精英”服装模型一样。

**一个关键区别**：它常与单例模式对比。单例确保一个类只有一个实例；而享元可以有多个实例（例如“恐怖分子服装”和“反恐精英服装”两个实例），且这些实例是**不可变**的

![享元设计模式技术图解.png](https://developer.qcloudimg.com/http-save/yehe-1367556/0c536ca634283c9dfd9f3990699cb6d2.png)
# 问题
1. **内存消耗爆炸**：这是最直接的问题。例如，在一个游戏中渲染一片森林（每棵树是一个独立对象）或一场激烈的交火（每个子弹、导弹是一个对象），每个对象都包含纹理、颜色、模型等大量数据。创建数十万、上百万个这样的独立实例，内存很快就会不堪重负。
2. **性能瓶颈**：大量的对象创建、销毁和垃圾回收会给CPU带来沉重负担，导致程序运行缓慢、卡顿。
3. **系统可维护性降低**：对象模型变得臃肿，每个对象都承载着全部数据，使得系统难以理解和优化。当需要新增一种共享属性时，修改点会遍布所有对象。

这就像为城市的每一盏路灯都独立设计和生产一套全新的模具，而不是使用标准化、可复用的灯罩和灯杆组件。

享元模式就是为了解决这种“重复造轮子”导致的资源浪费问题。
# 解决方案
享元模式提出了一种“分离与共享”的智慧。

它将对象的状态清晰地划分为两类：
- **内在状态 (Intrinsic State)**：对象中**不变的、可在多个上下文间共享**的部分。例如，在《反恐精英》游戏中，所有“恐怖分子”的3D服装模型、纹理和颜色是相同的。
- **外在状态 (Extrinsic State)**：对象中**变化的、取决于上下文、不可共享**的部分。例如，每个玩家独特的**位置坐标、生命值、当前使用的武器**。

![Gemini_Generated_Image_hytad3hytad3hyta.png](https://developer.qcloudimg.com/http-save/yehe-1367556/042c9b3df3dd01867aeccdf316b00389.png)

**模式如何工作？**
1. **创建享元工厂**：我们引入一个“享元工厂”。它的职责是管理享元对象的缓存池。当客户端请求一个享元时，工厂检查缓存中是否已存在具有所需内在状态的对象。如果有，直接返回；如果没有，则创建一个新的享元并加入缓存，然后返回。

2. **分离状态**：我们将原本庞大的对象拆解。**享元对象**只存储**内在状态**，并被大量共享。而**上下文对象**（Context，即原来的“玩家”、“子弹”对象）则持有对享元对象的引用以及属于它自己的**外在状态**。

3. **客户端协作**：客户端（或上下文对象）在需要执行操作时，将**外在状态**作为参数传递给享元对象的方法。
# 使用场景

- **程序需要创建海量相似对象**：这是最典型的场景，如游戏中的粒子系统（子弹、烟雾）、文档编辑器中的字符格式化对象、图形用户界面中的细粒度控件（如每个按钮的图标）。

- **内存是紧缺资源**：在嵌入式系统、移动设备或对性能要求极高的服务器应用中，减少内存占用是首要目标。

- **对象的大部分状态可以外部化**：经过分析，你发现对象的大部分属性是恒定的，只有少数几个属性在运行时频繁变化。
# 实现步骤
让我们以Go语言实现一个简单的例子：模拟一个文本编辑器，其中每个字符都是一个对象。如果不优化，每个字符都包含字体、大小、颜色等信息，内存消耗巨大。使用享元模式，我们可以将字体、大小、颜色作为内在状态共享

1. **定义享元接口和具体享元**
```
// flyweight.go - 享元对象 (存储内在状态)
package main

// Flyweight 接口
type TextCharacterFlyweight interface {
    Render(extrinsicState string) // 外在状态作为参数传入
}

// 具体享元
type CharacterFlyweight struct {
    fontFamily string
    fontSize   int
    color      string
}

func (c *CharacterFlyweight) Render(char string) {
    // 在实际应用中，这里会调用图形库API进行绘制
    // 渲染时，结合内在状态(fontFamily, fontSize, color)和外在状态(char)
    fmt.Printf("渲染字符 '%s'，使用字体：%s，大小：%d，颜色：%s\n",
        char, c.fontFamily, c.fontSize, c.color)
}
```
2. **创建享元工厂**
```
// flyweight_factory.go
package main

import "sync"

var (
    flyweightFactory *FlyweightFactory
    once             sync.Once
)

type FlyweightFactory struct {
    pool map[string]TextCharacterFlyweight // 用内在状态的组合作为键
    mu   sync.RWMutex
}

func GetFlyweightFactory() *FlyweightFactory {
    once.Do(func() {
        flyweightFactory = &FlyweightFactory{
            pool: make(map[string]TextCharacterFlyweight),
        }
    })
    return flyweightFactory
}

// 获取享元，如果不存在则创建
func (f *FlyweightFactory) GetFlyweight(fontFamily string, fontSize int, color string) TextCharacterFlyweight {
    key := fmt.Sprintf("%s_%d_%s", fontFamily, fontSize, color)

    f.mu.RLock()
    if flyweight, exists := f.pool[key]; exists {
        f.mu.RUnlock()
        return flyweight
    }
    f.mu.RUnlock()

    f.mu.Lock()
    defer f.mu.Unlock()
    // 双重检查，防止并发时重复创建
    if flyweight, exists := f.pool[key]; exists {
        return flyweight
    }

    flyweight := &CharacterFlyweight{
        fontFamily: fontFamily,
        fontSize:   fontSize,
        color:      color,
    }
    f.pool[key] = flyweight
    return flyweight
}
```

3. **上下文对象（使用享元的客户端）**

```
// context.go
package main

type CharacterContext struct {
    flyweight TextCharacterFlyweight
    char      string // 外在状态：具体的字符
    positionX int    // 外在状态：位置
    positionY int
}

func NewCharacterContext(fontFamily string, fontSize int, color string, char string, x, y int) *CharacterContext {
    factory := GetFlyweightFactory()
    flyweight := factory.GetFlyweight(fontFamily, fontSize, color)
    return &CharacterContext{
        flyweight: flyweight,
        char:      char,
        positionX: x,
        positionY: y,
    }
}

func (c *CharacterContext) Draw() {
    // 在实际渲染前，可能会根据positionX, Y进行坐标变换
    c.flyweight.Render(c.char) // 将外在状态 char 传递给享元
}
```

4. **客户端代码**
```
// main.go
package main

func main() {
    // 创建大量字符，但只共享少数几种样式
    document := []*CharacterContext{
        NewCharacterContext("Arial", 12, "Red", "H", 0, 0),
        NewCharacterContext("Arial", 12, "Red", "e", 10, 0),
        NewCharacterContext("Arial", 12, "Red", "l", 20, 0),
        NewCharacterContext("Arial", 12, "Red", "l", 30, 0),
        NewCharacterContext("Arial", 12, "Red", "o", 40, 0),
        NewCharacterContext("Times New Roman", 14, "Blue", "W", 0, 20),
        NewCharacterContext("Times New Roman", 14, "Blue", "o", 15, 20),
        NewCharacterContext("Times New Roman", 14, "Blue", "r", 30, 20),
        NewCharacterContext("Times New Roman", 14, "Blue", "l", 45, 20),
        NewCharacterContext("Times New Roman", 14, "Blue", "d", 60, 20),
    }

    for _, char := range document {
        char.Draw()
    }

    // 验证享元池中的对象数量远少于字符总数
    factory := GetFlyweightFactory()
    fmt.Printf("\n文档中共有 %d 个字符对象。\n", len(document))
    fmt.Printf("但享元池中只创建了 %d 个样式对象。\n", len(factory.pool)) // 应该是2个
}
```
# 优缺点
## **优点**：
- **极大节省内存**：这是最显著的优点，如果系统中存在大量重复对象，效果立竿见影。
- **可能提升性能**：减少了新对象的创建和垃圾回收的频率。
- **符合单一职责原则**：将状态分离到不同类中，使类的职责更清晰。

## **缺点**：
- **增加系统复杂度**：引入了工厂、享元、上下文等多个角色，代码结构变得复杂。新团队成员可能需要时间理解“为什么要把一个完整的对象拆开”。

- **可能牺牲执行速度**：为了获取共享对象，可能需要额外的查找（工厂查询）和计算（哈希键生成）。同时，外在状态需要作为参数传递，可能增加方法调用的开销。

- **线程安全问题**：享元工厂通常是多线程访问的，需要妥善处理并发（如上面代码使用 `sync.RWMutex`）。
# 总结
在软件设计中，**共享是美德，复用是智慧**。通过将对象的“灵魂”（内在状态）与“躯壳”（外在状态）分离，（也可称为：用户态 和 基本态），我们能够用有限的资源支撑起无限的可能。

享元模式是一种结构型设计模式，其核心目标是通过共享对象来高效支持大量细粒度对象，从而显著减少内存消耗，我称之为性能优化型设计模式。

享元设计模式-使用go语言实现

十倍工程师

编程语言

架构设计

享元模式是一种高效的结构型设计模式，通过共享相似对象的内在状态来减少内存消耗。适用于需要创建大量细粒度对象的场景，如游戏粒子系统、文本编辑器字符处理等。该模式将对象状态分为可共享的内在状态和个性化的外在状态，通过享元工厂管理共享对象，显著降低内存使用和对象创建开销，提升系统性能，特别适合资源受限环境。

嵌入式系统

软件设计

服务器

4核4G3M云服务器 新用户低至38元/年！

5位重磅专家聚焦 AI 时代开发者核心成长需求，带你深入解锁全栈进化、人机协作关键路径！点击报名到场：<a href="https://cloud.tencent.com/developer/salon/salon-2403/signup" target="_blank">https://cloud.tencent.com/developer/salon/salon-2403/signup</a><br/> 
 <img src="https://qcloudimg.tencent-cloud.cn/raw/487c82639d2338df3ef66dfb1450601a.png"/>

腾讯技术创作特训营「年度论坛」正在报名中！

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

享元设计模式-使用go语言实现-腾讯云开发者社区-腾讯云

享元设计模式-使用go语言实现

享元设计模式-使用go语言实现

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐