结构型模式之 享元模式

享元模式(Flyweight Pattern):运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象,而这些对象都很相似,状态变化很小,可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象,因此它又称为轻量级模式,它是一种对象结构型模式。

面向对象技术可以很好地解决一些灵活性或可扩展性问题,但在很多情况下需要在系统中增加类和对象的个数。当对象数量太多时,将导致运行代价过高,带来性能下降等问题。

  • 享元模式正是为解决这一类问题而诞生的。享元模式通过共享技术实现相同或相似对象的重用。
  • 在享元模式中可以共享的相同内容称为内部状态(IntrinsicState),而那些需要外部环境来设置的不能共享的内容称为外部状态(Extrinsic State),由于区分了内部状态和外部状态,因此可以通过设置不同的外部状态使得相同的对象可以具有一些不同的特征,而相同的内部状态是可以共享的。
  • 在享元模式中通常会出现工厂模式,需要创建一个享元工厂来负责维护一个享元池(Flyweight Pool)用于存储具有相同内部状态的享元对象。
  • 在享元模式中共享的是享元对象的内部状态,外部状态需要通过环境来设置。在实际使用中,能够共享的内部状态是有限的,因此享元对象一般都设计为较小的对象,它所包含的内部状态较少,这种对象也称为细粒度对象。享元模式的目的就是使用共享技术来实现大量细粒度对象的复用。

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

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

如何解决:用唯一标识码判断,如果在内存中有,则返回这个唯一标识码所标识的对象。

关键代码:用 HashMap 存储这些对象。

优点:大大减少对象的创建,降低系统的内存,使效率提高。

缺点:提高了系统的复杂度,需要分离出外部状态和内部状态,而且外部状态具有固有化的性质,不应该随着内部状态的变化而变化,否则会造成系统的混乱。

使用场景: 1、系统有大量相似对象。 2、需要缓冲池的场景。

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

实现

我们将创建一个 Shape 接口和实现了 Shape 接口的实体类 Circle。下一步是定义工厂类 ShapeFactory

ShapeFactory 有一个 Circle 的 HashMap,其中键名为 Circle 对象的颜色。无论何时接收到请求,都会创建一个特定颜色的圆。ShapeFactory 检查它的 HashMap 中的 circle 对象,如果找到 Circle 对象,则返回该对象,否则将创建一个存储在 hashmap 中以备后续使用的新对象,并把该对象返回到客户端。

FlyWeightPatternDemo,我们的演示类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息(red / green / blue/ black / white),以便获取它所需对象的颜色。

#include<iostream>
#include<memory>
#include<list>
#include<map>
#include <utility>
#include<time.h>
#include<string>
using namespace std;

//步骤一 创建一个接口
class Shape
{
public:
    virtual void draw() {}
};
//步骤二 创建实现接口的实体类

class Circle : public Shape
{
private:
    std::string color;
    int x;
    int y;
    int radius;
public:
    Circle() { color = "red"; x = y = radius = 0; }
    Circle(string Color) { color = Color; }
    void SetX(int X) { x = X; cout << "x = " << x << endl; }
    void SetY(int Y) { y = Y; }
    void SetRadius(int Radius) { radius = Radius; }
    void draw()
    {
        std::cout << "Circle::draw() color = " << color << "  x = " << x << "  y = " << y << "   radius = " << radius << std::endl;
    }
};

//步骤 3    创建一个工厂,生成基于给定信息的实体类的对象
class ShapeFactory
{
private:
    static std::map<string, Shape*> circleMap;
public:
    static Shape* GetCircle(string color)
    {
        if (color.empty())
            return NULL;
        std::map<string, Shape*>::iterator ite = circleMap.find(color);
        if (ite != circleMap.end())
            return(ite->second);
        else
        {
            Shape* shapetmp = new Circle;
            pair<string, Shape*> p1;
            p1 = make_pair(color, shapetmp);
            circleMap.insert(p1);
            cout << "Creating circle of color : " << color << endl;
            std::map<string, Shape*>::iterator ite2 = circleMap.find(color);
            if (ite2 != circleMap.end())
                return(ite2->second);
            return NULL;
        }
    }
    ShapeFactory() {
    }
};
map<string, Shape*>ShapeFactory::circleMap;  //静态成员变量一定要初始化,否则出现链接问题

int main()
{

    string colors[] =
    { "Red", "Green", "Blue", "White", "Black" };
    srand((int)time(0));
    string s1 = colors[rand() % colors->size()];
    cout << s1 << endl;
    for (int i = 0; i < 20; ++i) {

        Circle* circle = (Circle*)ShapeFactory::GetCircle(s1);
        circle->SetX(rand() % 100);
        circle->SetY(rand() % 100);
        circle->SetRadius(rand() % 100);
        circle->draw();
    }
    return 0;
}//未考虑new的内存释放问题,说明一下

原文地址:https://www.cnblogs.com/gardenofhu/p/8505013.html

时间: 2024-10-29 21:11:05

结构型模式之 享元模式的相关文章

结构型设计模式之享元模式

结构 意图 运用共享技术有效地支持大量细粒度的对象. 适用性 一个应用程序使用了大量的对象. 完全由于使用大量的对象,造成很大的存储开销. 对象的大多数状态都可变为外部状态. 如果删除对象的外部状态,那么可以用相对较少的共享对象取代很多组对象. 应用程序不依赖于对象标识.由于F l y w e i g h t 对象可以被共享,对于概念上明显有别的对象,标识测试将返回真值. 1 using System; 2 using System.Collections; 3 4 class Flyweigh

java-设计模式(结构型)-【享元模式】

1.享元模式(Flyweight) 定义:享元模式的主要目的是实现对象的共享,即共享池,当系统中对象多的时候可以减少内存的开销,通常与工厂模式一起使用.   1.1 工厂 //工厂:内置一个池,如果存在了则取出,否则则创建加入池中 public class FactoryPool { private Hashtable<String,Person> pool=new Hashtable<String,Person>(); public Person getPerson(String

15结构型模式之享元模式

概念 Flyweight模式也叫享元模式,是构造型模式之一,它通过与其他类似对象共享数据来减小内存占用. 角色和职责 抽象享元角色: 所有具体享元类的父类,规定一些需要实现的公共接口. 具体享元角色: 抽象享元角色的具体实现类,并实现了抽象享元角色规定的方法. 享元工厂角色: 负责创建和管理享元角色. 使用场景: 是以共享的方式,高效的支持大量的细粒度的对象. 案例 //相同的信息,但不是同一个人. #include <iostream> using namespace std; #inclu

结构型模式之享元模式

GitHub地址:https://github.com/zhangboqing/design-mode/tree/master/src/main/java/com/zbq 一.定义 享元模式(Flyweight Pattern):运用共享技术有效地支持大量细粒度对象的复用.系统只使用少量的对象,而这些对象都很相似,状态变化很小,可以实现对象的多次复用.由于享元模式要求能够共享的对象必须是细粒度对象,因此它又称为轻量级模式,它是一种对象结构型模式. 二.模式结构成员构成 ? Flyweight:

装饰者模式、享元模式

一.装饰者模式 装饰模式与继承模式的目的都是扩展对象的功能,但是装饰模式比继承有更多的灵活性. 齐天大圣 c =new 大圣本尊():齐天大圣 fish = new 鱼儿(c):齐天大圣 bird = new 雀儿(fish); 二.享元模式 享元对象以共享的方式高效地支持大量的细粒度对象, 享元对象能做到共享的关键,是区分内部状态和外部状态,一个外部状态是随环境而改变的,不可共享,存储在客户端:内部状态是存储在享元对象的内部,不随环境而改变. -------------------------

用最简单的例子说明设计模式(三)之责任链、建造者、适配器、代理模式、享元模式

责任链模式 一个请求有多个对象来处理,这些对象是一条链,但具体由哪个对象来处理,根据条件判断来确定,如果不能处理会传递给该链中的下一个对象,直到有对象处理它为止 使用场景 1)有多个对象可以处理同一个请求,具体哪个对象处理该请求待运行时刻再确定 2)在不明确指定接收者的情况下,向多个对象中的一个提交一个请求 3)可动态指定一组对象处理请求,客户端可以动态创建职责链来处理请求 public class Chain { public abstract class Handler { private

设计模式---对象性能模式之享元模式(Flyweight)

一:概念 通过与其他类似对象共享数据来减少内存占用 如果一个应用程序使用了太多的对象, 就会造成很大的存储开销. 特别是对于大量轻量级 (细粒度)的对象,比如在文档编辑器的设计过程中,我们如果为每个字母创建一个对象的话,系统可能会因为大量的对象而造成存储开销的浪费.例如一个字母“a”在文档中出现了100000 次,而实际上我们可以让这一万个字母“a”共享一个对象,当然因为在不同的位置可能字母“a”有不同的显示效果(例如字体和大小等设置不同) ,在这种情况我们可以为将对象的状态分为“外部状态”和“

java设计模式5.组合模式、门面模式、享元模式、桥接模式

组合模式 在面向对象的语言中,树结构有着巨大的威力,一个基于继承的类型的等级结构便是一个数结构,一个基于合成的对象结构也是一个数结构.组合模式将部分与整体的关系用树结构表示出来,使得客户端把一个个单独的成分对象和由它们组合而成的合成对象同等看待. 抽象构建角色:一个抽象角色,给参加组合的对象规定一个接口,这个接口给出共有的接口及默认行为. 树叶构建角色:代表参加组合的树叶对象,没有子对象,定义参加组合的原始对象行为. 树枝构建角色:代表参加组合的有子对象的对象,并给出树枝构件对象的行为. 对于子

第13章 结构型模式—享元模式

1. 享元模式(Flyweight Pattern)的定义 (1)运用共享技术高效地支持大量细粒度的对象 ①对象内部状态:数据不变且重复出现,这部分不会随环境变化而改变,是可以共享的. ②对象外部状态:数据是变化的,会随环境变化而改变,是不可以共享的. ③所谓的享元,就是把内部状态的数据分离出来共享,通过共享享元对象,可以减少对内存的占用.把外部状态分离出来,放到外部,让应用程序在使用的时候进行维护,并在需要的时候传递给享元对象使用. ④享元模式真正缓存和共享的是享元的内部状态,而外部状态是不被