结构型设计模式之亨元模式【设计模式系列】

深碍√TFBOYSˉ_ 2024-03-22 19:50 41阅读 0赞

## 系列文章目录 ##

[C++技能系列][C]  
[Linux通信架构系列][Linux]  
[C++高性能优化编程系列][C 1]  
[深入理解软件架构设计系列][Link 1]  
[高级C++并发线程编程][C 2]  
[设计模式系列][Link 2]

**期待你的关注哦！！！**  
![在这里插入图片描述][b09b24d6d28c4d7f9557fdf640801a16.png_pic_left]

***`现在的一切都是为将来的梦想编织翅膀，让梦想在现实中展翅高飞。`***  
***`Now everything is for the future of dream weaving wings, let the dream fly in reality.`***

#### 结构型设计模式之亨元模式 ####

*  系列文章目录
 *  一、亨元模式介绍
 *  二、亨元模式优缺点
 *   *  2.1 优点
     *  2.2 缺点
 *  三、亨元模式使用场景
 *  四、亨元模式实现
 *  五、总结

## 一、亨元模式介绍 ##

**`亨元模式？不知道为啥起这么奇怪的名字！！！`**

**简单的理解: 一个类的成员非常多，创建此对象很消耗资源，在实际场景中又需要反复创建和销毁该对象。所消耗的内存，就更加庞大。**

**如果此时设计一个对象池，里面缓存一定的对象，软件在用时申请，不用时回收。就能实现对象的重复利用，而多次创建和销毁对象。**

**`什么是享元模式？`**

**说到享元模式，第一个想到的应该就是池技术了，String常量池、数据库连接池、缓冲池等等都是享元模式的应用，所以说享元模式是池技术的重要实现方式。**

**比如我们每次创建字符串对象时，都需要创建一个新的字符串对象的话，内存开销会很大，所以如果第一次创建了字符串对象“adam“，下次再创建相同的字符串”adam“时，只是把它的引用指向”adam“，这样就实现了”adam“字符串再内存中的共享。**

**举个最简单的例子，网络联机下棋的时候，一台服务器连接了多个客户端（玩家），如果我们每个棋子都要创建对象，那一盘棋可能就有上百个对象产生，玩家多点的话，因为内存空间有限，一台服务器就难以支持了，所以这里要使用享元模式，将棋子对象减少到几个实例。**

⚠️ **`意图：`**  
运用共享技术有效地支持大量细粒度的对象。

⚠️ **`主要解决：`**  
在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。。

⚠️ **`何时使用：`**  
1、系统中有大量对象。 2、这些对象消耗大量内存。 3、这些对象的状态大部分可以外部化。 4、这些对象可以按照内蕴状态分为很多组，当把外蕴对象从对象中剔除出来时，每一组对象都可以用一个对象来代替。 5、系统不依赖于这些对象身份，这些对象是不可分辨的。

⚠️ **`如何解决：`**  
用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象。

![在这里插入图片描述][77ac4aec19124277a12c64eab262f135.png_pic_center]

图1\_1 亨元模式类图

因为要求细粒度对象，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。

**内部状态指对象共享出来的信息，存储在享元对象内部并且不会随环境的改变而改变；**  
**外部状态指对象得以依赖的一个标记，是随环境改变而改变的、不可共享的状态。**

## 二、亨元模式优缺点 ##

### 2.1 优点 ###

大大减少了对象的创建，降低了程序内存的占用，提高效率

*  享元模式的优点在于它可以极大减少内存中对象的数量，使得相同对象或相似对象在内存中只保存一份。
 *  享元模式的外部状态相对独立，而且不会影响其内部状态，从而使得享元对象可以在不同的环境中被共享。

### 2.2 缺点 ###

提高了系统的复杂度。需要分离出内部状态和外部状态，而外部状态具有固化特性，不应该随着内部状态的改变而改变

*  享元模式使得系统更加复杂，需要分离出内部状态和外部状态，这使得程序的逻辑复杂化。
 *  为了使对象可以共享，享元模式需要将享元对象的状态外部化，而读取外部状态使得运行时间变长。

享元模式可以避免大量非常相似类的开销。在程序设计中，有时需要生成大量细粒度的类实例来表示数据。如果能发现这些实例除了几个参数外基本上都是相同的，有时就能够大幅度的减少需要实例化的类的数量。如果能把那些参数移到类实例的外面，在方法调用时将它们传递进来，就可以通过共享大幅度地减少单个实例的数目。

也就是说，享元模式Flyweight执行时所需的状态是有内部的也可能有外部的，内部状态存储于ConcreteFlyweight对象之中，而外部对象则应该考虑由客户端对象存储或计算，当调用Flyweight对象的操作时，将该状态传递给它。

## 三、亨元模式使用场景 ##

*  系统中存在大量相似对象
 *  需要缓冲池的场景

注意事项：  
注意划分内部状态和外部状态，否则可能会引起线程安全问题；  
这些类必须有一个工厂类加以控制。

## 四、亨元模式实现 ##

**Flyweight抽象类**  
所有具体享元类的超类或接口，通过这个接口，Flyweight可以接受并作用于外部状态。

#ifndef FLYWEIGHT_FLYWEIGHT_H
    #define FLYWEIGHT_FLYWEIGHT_H
    
    #include <iostream>
    #include <string>
    #include <utility>
    
    using namespace std;
    class Flyweight {
        
    public:
        explicit Flyweight(string extrinsic) {
        
            extrinsic_ = std::move(extrinsic);
        }
    
        virtual ~Flyweight() = default;
        //定义业务操作
        virtual void operate(int extrinsic) = 0;
    
        string getIntrinsic() const {
        
            return intrinsic_;
        }
    
        void setIntrinsic(string intrinsic) {
        
            intrinsic_ = std::move(intrinsic);
        }
    
    public:
        string intrinsic_; //内部状态
    protected:
        //要求享元角色必须接受外部状态
        string extrinsic_;//外部状态
    
    };
    
    
    #endif //FLYWEIGHT_FLYWEIGHT_H

**ConcreteFlyweight类**  
继承Flyweight超类或实现Flyweight接口，并为其内部状态增加存储空间。

#ifndef FLYWEIGHT_CONCRETEFLYWEIGHT_H
    #define FLYWEIGHT_CONCRETEFLYWEIGHT_H
    
    #include "Flyweight.h"
    
    class ConcreteFlyweight : public Flyweight{
        
        //接受外部状态
    public:
        explicit ConcreteFlyweight(string extrinsic) : Flyweight(std::move(extrinsic)) {
        }
        ~ ConcreteFlyweight() = default;
        //根据外部状态进行逻辑处理
        void operate(int extrinsic) override {
        
            cout << "具体Flyweight:" << extrinsic << endl;
        }
    };
    
    
    #endif //FLYWEIGHT_CONCRETEFLYWEIGHT_H

**UnsharedConcreteFlyweight类**  
指那些不需要共享的Flyweight子类。

#ifndef FLYWEIGHT_UNSHAREDCONCRETEFLYWEIGHT_H
    #define FLYWEIGHT_UNSHAREDCONCRETEFLYWEIGHT_H
    
    #include "Flyweight.h"
    
    class UnsharedConcreteFlyweight : public Flyweight{
        
    public:
        explicit UnsharedConcreteFlyweight(string extrinsic) : Flyweight(std::move(extrinsic)) {
        }
        ~UnsharedConcreteFlyweight() = default;
        //根据外部状态进行逻辑处理
        void operate(int extrinsic) override {
        
            cout << "不共享的具体Flyweight:" << extrinsic << endl;
        }
    };
    
    
    #endif //FLYWEIGHT_UNSHAREDCONCRETEFLYWEIGHT_H

**FlyweightFactory类**  
一个享元工厂，用来创建并管理Flyweight对象，主要是用来确保合理地共享Flyweight，当用户请求一个Flyweight时，FlyweightFactory对象提供一个已创建的实例或创建一个实例。

#include "Flyweight.h"
    #include "ConcreteFlyweight.h"
    #include <map>
    #include <memory>
    
    using namespace std;
    
    class FlyweightFactory {
        
    public:
        FlyweightFactory() = default;
        ~FlyweightFactory() = default;
    
        //享元工厂
    public:
         shared_ptr<Flyweight> GetFlyweight(string extrinsic) {
        
            cout << extrinsic << endl;
            shared_ptr<Flyweight> flyweightPtr = nullptr;
            auto a = pool_.find(extrinsic);
            if(pool_.find(extrinsic) != pool_.end()) {
            //池中有该对象
                flyweightPtr = pool_.at(extrinsic);
                cout << "已有 " << extrinsic << " 直接从池中取---->" << endl;
            } else {
        
                //根据外部状态创建享元对象
                flyweightPtr = make_shared<ConcreteFlyweight>(extrinsic);
                //放入池中
                pool_.emplace(extrinsic, flyweightPtr);
               cout << "创建 " << extrinsic  <<  " 并从池中取出---->" << endl;
            }
    
            return flyweightPtr;
        }
    
        //定义一个池容器
    private:
         map<string, shared_ptr<Flyweight>> pool_;
    };
    
    
    #endif //FLYWEIGHT_FLYWEIGHTFACTORY_H

**Client客户端**

#include <iostream>
    #include "Flyweight.h"
    #include "FlyweightFactory.h"
    #include "UnsharedConcreteFlyweight.h"
    
    using namespace std;
    int main() {
        
        int extrinsic = 22;
    
        FlyweightFactory factory;
    
        shared_ptr<Flyweight> flyweightX = factory.GetFlyweight("X");
        flyweightX->operate(++extrinsic);
    
        shared_ptr<Flyweight> flyweightY = factory.GetFlyweight("Y");
        flyweightY->operate(++extrinsic);
    
        shared_ptr<Flyweight> flyweightZ = factory.GetFlyweight("Z");
        flyweightZ->operate(++extrinsic);
    
        shared_ptr<Flyweight> flyweightReX = factory.GetFlyweight("X");
        flyweightReX->operate(++extrinsic);
    
        shared_ptr<UnsharedConcreteFlyweight> unsharedFlyweight = make_shared<UnsharedConcreteFlyweight>("X") ;
        unsharedFlyweight->operate(++extrinsic);
    
        return 0;
    }

运行结果如下：  
![在这里插入图片描述][2838727243224cf39b5688fca7fb4164.jpeg_pic_center]

图1\_2 运行结果

从这个结果我们可以看出来，第一次创建X、Y、Z时，都是先创建再从池中取出，而第二次创建X时，因为池中已经存在了，所以直接从池中取出，这就是享元模式。

## 五、总结 ##

与其他相关模式：

客户端要引用享元对象，是通过工厂对象创建或者获得的，客户端每次引用一个享元对象，都是可以通过同一个工厂对象来引用所需要的享元对象。因此，可以将享元工厂设计成单例模式，这样就可以保证客户端只引用一个工厂实例。因为所有的享元对象都是由一个工厂对象统一管理的，所以在客户端没有必要引用多个工厂对象。不管是单纯享元模式还是复合享元模式中的享元工厂角色，都可以设计成为单例模式，对于结果是不会有任何影响的。

Composite模式：Flyweight模式通常和Composite 模式结合起来，用共享叶结点的有向无环图实现一个逻辑上的层次结构。复合享元模式实际上是单纯享元模式与合成模式的组合。单纯享元对象可以作为树叶对象来讲，是可以共享的，而复合享元对象可以作为树枝对象， 因此在复合享元角色中可以添加聚集管理方法。通常，最好用Flyweight实现State 和Strategy 对象。

小结：

1.  享元模式是一个考虑系统性能的设计模式，通过使用享元模式可以节约内存空间，提高系统的性能。
2.  享元模式的核心在于享元工厂类，享元工厂类的作用在于提供一个用于存储享元对象的享元池，用户需要对象时，首先从享元池中获取，如果享 元池中不存在，则创 建一个新的享元对象返回给用户，并在享元池中保存该新增对象。
3.  享元模式以共享的方式高效地支持大量的细粒度对象，享元对象能做到共享的关键是区分内部状态(Internal State)和外部状态(External State)。  
    (1) 内部状态是存储在享元对象内部并且不会随环境改变而改变的状态，因此内部状态可以共享。  
    (2) 外部状态是随环境改变而改变的、不可以共享的状态。享元对象的外部状态必须由客户端保存，并在享元对象被创建之后，在需要使用的时候 再传入到享元对 象内部。一个外部状态与另一个外部状态之间是相互独立的。

[C]: https://blog.csdn.net/weixin_30197685/category_12344315.html
[Linux]: https://blog.csdn.net/weixin_30197685/category_12353489.html
[C 1]: https://blog.csdn.net/weixin_30197685/category_12332626.html
[Link 1]: https://blog.csdn.net/weixin_30197685/category_12332639.html
[C 2]: https://blog.csdn.net/weixin_30197685/category_12332628.html
[Link 2]: https://blog.csdn.net/weixin_30197685/category_12387201.html
[b09b24d6d28c4d7f9557fdf640801a16.png_pic_left]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/5c74d848206748839353a21a298d51b7.png
[77ac4aec19124277a12c64eab262f135.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/26a4c870d70a4a0fbe107ba12e67d2e9.png
[2838727243224cf39b5688fca7fb4164.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/3231526862b24c608da1ce3d993a5c3c.png