设计模式14-享元模式

由来动机

在很多应用中，可能会创建大量相似对象，例如在文字处理器中每个字符对象。在这些场景下，如果每个对象都存在，将会导致巨大的内存开销。那么如何在避免大量颗粒度对象问题的同时，让外部客户程序仍然能够透明的使用面向对象的方式来进行操作呢?享元模式的主要动机是通过共享相似对象来减少内存使用，提高系统性能,来解决此类问题。

享元模式适用于以下情况：

• 应用程序使用大量相同或相似对象。
• 对象的大部分状态可以外部化，从而使得许多对象能够共享同一个实例。
• 需要支持大量细粒度对象高效地共享和复用。

定义与结构

模式定义: 运用共享技术有效地支持大量细粒度的对象。–《设计模式》GoF

享元模式由以下几个主要角色组成：

以下是享元模式的UML图：

代码推导

下面我们通过C++代码示例来实现享元模式。

1. 定义Flyweight接口：

class Flyweight {
public:
    virtual void operation(int extrinsicState) = 0;
    virtual ~Flyweight() = default;
};

2. 实现具体享元类：

#include <iostream>

class ConcreteFlyweight : public Flyweight {
private:
    int intrinsicState;

public:
    ConcreteFlyweight(int state) : intrinsicState(state) {}

    void operation(int extrinsicState) override {
        std::cout << "Intrinsic State: " << intrinsicState 
                  << ", Extrinsic State: " << extrinsicState << std::endl;
    }
};

3. 实现享元工厂类：

#include <unordered_map>
#include <memory>

class FlyweightFactory {
private:
    std::unordered_map<int, std::shared_ptr<Flyweight>> flyweights;

public:
    std::shared_ptr<Flyweight> getFlyweight(int key) {
        if (flyweights.find(key) == flyweights.end()) {
            flyweights[key] = std::make_shared<ConcreteFlyweight>(key);
        }
        return flyweights[key];
    }
};

4. 使用享元模式：

int main() {
    FlyweightFactory factory;
    std::shared_ptr<Flyweight> fw1 = factory.getFlyweight(1);
    std::shared_ptr<Flyweight> fw2 = factory.getFlyweight(2);
    std::shared_ptr<Flyweight> fw3 = factory.getFlyweight(1); // Reuses the existing Flyweight

    fw1->operation(10);
    fw2->operation(20);
    fw3->operation(30);

    return 0;
}

特点

1. 共享对象： 通过共享细粒度对象，减少内存使用，提高性能。
2. 内部状态和外部状态： 将对象的状态分为内部状态和外部状态，内部状态存储在享元对象中，而外部状态由客户端传入。
3. 不可变性： 享元对象是不可变的，确保共享时不会被其他对象修改。
4. 工厂管理： 使用享元工厂管理享元对象的创建和共享，确保唯一实例。

享元模式的应用

享元模式在以下场景中非常有用：

1. 文本处理： 文本编辑器中，每个字符都是一个对象，通过享元模式共享字符对象，减少内存消耗。
2. 图形系统： 在图形系统中，大量相似的图形对象可以通过享元模式共享，例如树木、建筑物等。
3. 缓存： 使用享元模式实现对象缓存，避免重复创建相同的对象。
4. 游戏开发： 在游戏开发中，使用享元模式共享相同类型的游戏对象，例如敌人、子弹等，减少内存使用。

总结

• 面对对象很好的解决了抽象性的问题，但是作为一个运行在机器中的程序实体我们需要考虑对象的代价问题。享元模式主要解决面向对象的代价问题,一般不触及面向对象的抽象性问题。
• 享元模式采用对象共享的方法来降低系统中对象的个数,从而降低细粒度对象给系统带来的内存压力。在具体实践方面要注意对象状态的处理。
• 对象的数量太大，从而导致对象内存开销加大，什么样的数量才算大？这需要我们仔细的根据具体应用情况进行评估，而不能评空臆断。

优点

1. 减少内存消耗： 通过共享细粒度对象，享元模式大大减少了内存的使用。当有大量相似对象需要创建时，享元模式特别有效。
2. 提升性能： 由于减少了内存使用，享元模式可以提升系统的性能，特别是在内存有限或系统资源紧张的情况下。
3. 分离内部状态和外部状态： 享元模式将对象的状态分为内部状态（共享部分）和外部状态（非共享部分），使得对象更加轻量化。

缺点

1. 复杂性增加： 享元模式引入了额外的复杂性，特别是在处理对象状态时，需要明确区分内部状态和外部状态。
2. 维护困难： 享元模式需要维护一个共享对象的池，这增加了代码的复杂性和维护难度。
3. 线程安全问题： 在多线程环境下，需要确保享元对象的线程安全性，可能需要引入额外的同步机制，影响性能。

使用享元模式的注意事项

1. 区分内部状态和外部状态： 在使用享元模式时，需要明确区分哪些状态可以共享（内部状态），哪些状态是对象独有的（外部状态）。
2. 适用场景： 享元模式适用于有大量相似对象的场景，例如图形系统、文本处理、游戏开发等。如果对象数量不多，或者对象之间差异较大，使用享元模式的意义不大。
3. 线程安全： 在多线程环境下，共享的享元对象需要是线程安全的。可以使用锁（例如std::mutex）或者其他同步机制确保线程安全。
4. 内存泄漏： 享元模式中的享元工厂负责管理共享对象，需要确保及时释放不再使用的共享对象，以避免内存泄漏。
5. 性能权衡： 虽然享元模式可以减少内存使用，但也会引入一些性能开销，例如对象池的维护、同步机制的使用等。在设计时需要权衡这些开销。