享元模式（Flyweight Pattern）是一种结构型设计模式，用于减少创建对象的数量，从而减少内存占用和提高性能-CSDN博客

本文链接：https://blog.csdn.net/blog_programb/article/details/147817737

享元模式（Flyweight Pattern）是一种结构型设计模式，用于减少创建对象的数量，从而减少内存占用和提高性能。享元模式的核心思想是通过共享已存在的对象来避免重复创建相同或相似的对象，从而节省内存。

1. 享元模式的主要角色

享元接口（Flyweight）：声明了享元对象可以执行的操作，通常是一个接口或抽象类。
具体享元类（ConcreteFlyweight）：实现了享元接口，定义了享元对象的具体行为。
非享元类（UnsharedConcreteFlyweight）：不需要共享的对象，通常包含内部状态。
享元工厂（FlyweightFactory）：负责创建和管理享元对象，确保共享对象的唯一性。

2. 享元模式的实现步骤

定义享元接口：声明享元对象可以执行的操作。
实现具体享元类：实现享元接口，定义享元对象的具体行为。
定义非享元类：实现不需要共享的对象。
实现享元工厂：负责创建和管理享元对象，确保共享对象的唯一性。
客户端代码：通过享元工厂获取享元对象，并调用其方法。

3. 示例代码

假设我们有一个文本编辑器，支持多种字体和颜色。我们可以使用享元模式来减少字体对象的数量，从而节省内存。

3.1 定义享元接口

public interface Font {
    void display(String text);
}

3.2 实现具体享元类

public class FontImpl implements Font {
    private String name;
    private String color;

    public FontImpl(String name, String color) {
        this.name = name;
        this.color = color;
    }

    @Override
    public void display(String text) {
        System.out.println("显示字体: " + name + ", 颜色: " + color + ", 文本: " + text);
    }
}

3.3 实现享元工厂

import java.util.HashMap;
import java.util.Map;

public class FontFactory {
    private static final Map<String, Font> fonts = new HashMap<>();

    public static Font getFont(String name, String color) {
        String key = name + "-" + color;
        if (!fonts.containsKey(key)) {
            Font font = new FontImpl(name, color);
            fonts.put(key, font);
        }
        return fonts.get(key);
    }
}

3.4 客户端代码

public class Main {
    public static void main(String[] args) {
        // 获取字体对象
        Font font1 = FontFactory.getFont("Arial", "Red");
        Font font2 = FontFactory.getFont("Arial", "Red");
        Font font3 = FontFactory.getFont("Times New Roman", "Blue");

        // 显示文本
        font1.display("Hello, World!");
        font2.display("This is Arial font.");
        font3.display("This is Times New Roman font.");

        // 检查是否共享
        System.out.println(font1 == font2); // true
    }
}

4. 输出结果

运行客户端代码，输出结果如下：

显示字体: Arial, 颜色: Red, 文本: Hello, World!
显示字体: Arial, 颜色: Red, 文本: This is Arial font.
显示字体: Times New Roman, 颜色: Blue, 文本: This is Times New Roman font.
true

5. 享元模式的优点

节省内存：通过共享已存在的对象，减少创建对象的数量，从而节省内存。
提高性能：减少了对象的创建和销毁操作，提高了系统的性能。
符合开闭原则：对扩展开放，对修改封闭，无需修改现有代码即可添加新功能。

6. 适用场景

享元模式适用于以下场景：

当系统中有大量相似对象时，这些对象的大部分状态可以外部化。
当需要减少对象的数量，以节省内存和提高性能时。
当对象的内部状态独立于外部状态时。

通过享元模式，可以有效地减少对象的数量，节省内存，提高系统的性能。
享元模式（Flyweight Pattern）是一种结构型设计模式，其核心目的是通过共享对象来减少内存使用和提高性能。该模式会尽量复用已存在的细粒度对象，避免大量拥有相同内容的小对象的重复创建，从而降低系统中对象的数量，节省系统资源。

核心概念

享元（Flyweight）：定义了享元对象的接口，通常包含一些能被共享的状态和操作。
具体享元（Concrete Flyweight）：实现了享元接口，存储了内部状态（不会随环境改变而改变的状态），并提供操作这些状态的方法。
享元工厂（Flyweight Factory）：负责创建和管理享元对象，它维护一个享元池（通常是一个数据结构，如字典），当请求一个享元对象时，先检查池中是否已存在，如果存在则直接返回，不存在则创建新的享元对象并放入池中。
客户端（Client）：使用享元对象，通过享元工厂获取所需的享元对象，并可以向享元对象传入外部状态（随环境改变而改变的状态）。

主要作用

减少内存占用：通过共享对象，避免了大量重复对象的创建，显著降低了内存使用。
提高性能：减少对象创建和销毁的开销，提高系统的响应速度。
分离内部状态和外部状态：使得内部状态可以被多个对象共享，外部状态由客户端在使用时传入。

典型场景

系统中存在大量相似对象：如文本编辑器中的字符、图形系统中的图形元素等。
对象的状态可以分为内部状态和外部状态：内部状态可共享，外部状态可在使用时动态设置。
需要缓冲池的场景：如线程池、连接池等，本质上也是享元模式的应用。

示例结构

以下是一个使用 Python 实现的简单享元模式示例，模拟文本编辑器中字符的共享：

# 享元接口
class CharacterFlyweight:
    def render(self, font_size):
        pass

# 具体享元
class ConcreteCharacter(CharacterFlyweight):
    def __init__(self, char):
        self.char = char

    def render(self, font_size):
        return f"渲染字符 {self.char}，字号为 {font_size}"

# 享元工厂
class CharacterFactory:
    def __init__(self):
        self.flyweights = {}

    def get_character(self, char):
        if char not in self.flyweights:
            self.flyweights[char] = ConcreteCharacter(char)
        return self.flyweights[char]

# 客户端代码
if __name__ == "__main__":
    factory = CharacterFactory()

    # 获取字符 'A' 的享元对象
    char_a1 = factory.get_character('A')
    char_a2 = factory.get_character('A')
    # 验证是否为同一个对象
    print(char_a1 is char_a2)

    # 使用享元对象并传入外部状态
    print(char_a1.render(12))
    print(char_a2.render(16))

    # 获取字符 'B' 的享元对象
    char_b = factory.get_character('B')
    print(char_b.render(14))

优点

节省内存：减少了系统中对象的数量，降低了内存开销，尤其在处理大量相似对象时效果显著。
提高性能：减少对象创建和销毁的开销，加快系统的运行速度。
可维护性增强：将内部状态和外部状态分离，使得代码结构更加清晰，便于维护。

缺点

增加系统复杂度：引入了享元工厂和内部/外部状态的概念，使得系统的设计和理解变得复杂。
线程安全问题：如果多个线程同时访问和修改享元对象，可能会出现线程安全问题，需要进行额外的同步处理。
外部状态管理困难：客户端需要负责管理和传递外部状态，增加了客户端的复杂度。

与其他模式的区别

享元模式 vs 单例模式：
- 单例模式确保一个类只有一个实例，并提供全局访问点。它关注的是类的实例数量，一个类只能有一个实例。
- 享元模式关注的是对象的共享，同一类可以有多个实例，但这些实例中的部分状态是共享的，目的是减少内存使用。
享元模式 vs 缓存模式：
- 缓存模式主要用于临时存储数据，以提高数据的访问速度，它通常是对一些计算结果或数据的临时存储。
- 享元模式更侧重于对象的共享，通过复用对象来减少内存消耗，不仅存储数据，还涉及对象的创建和管理。

享元模式在实际开发中常用于图形处理、游戏开发、文本处理等领域，当系统需要处理大量细粒度对象且这些对象存在可共享的状态时，使用享元模式可以有效地优化系统性能和资源利用。
在这里插入图片描述