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

一、简介

享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。

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

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

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

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

 

其实享元模式的实现与单例模式的实现方式十分相似，比如：单例模式实现的是一个类对象只允许有一个实例对象，而享元模式则是一个类对象只允许创建不同类型的对象，这样保证同一类型的对象共享不可变数据。

 

享元模式是一种用于解决资源和性能压力时会使用到的设计模式，它的核心思想是通过引入数据共享来提升性能。

# 例如在开发3D游戏时，例如有成千上万的士兵或者有成千上万棵树，如果一个3D地带的每个对象都单独创建，不使用数据共享，那么性能是无法接受的。

 

既然要创建成千上万个士兵，那么若他们的数据属性行为都是一样的，那岂不是黏一块去了。这时候就会有：可变数据和不可变数据的概念。

即 -- 重点在于将不可变（可共享）的属性与可变的属性区分开。

相同类型的对象共享不可变（可共享）的数据，而每个对象又有其独立的数据，这部分数据即为：可变的属性（不可共享数据）。

可以通过__new__()方法创建可共享的对象,例如树的种类:苹果树、樱桃树等,并保存到一个字典中,若要创建相同类型的树木,则可以继续使用字典中的树木类型

使用通过__init__()方法实例化不可共享的数据,例如树的高度、粗壮等

 

二、具体实现:以种植三种树为例:十棵苹果树、三棵樱桃树、五棵桃树

第一步:创建一个抽象类--树木类: 重写__new__方法,用于生成树的种类对象, 重写__init__方法,用于生成树的不可共享数据

class Tree:
    pool = dict()   # 创建一个空字典

    def __new__(cls, tree_type, *args, **kwargs):
        obj = cls.pool.get(tree_type, None) # 从字典中获取是否有该树木类型
        if not obj: # 没有该类型，则实例化该类型
            obj = super().__new__(cls, *args, **kwargs) # 调用父类的方法实例化对象
            cls.pool[tree_type] = obj   # 将该对象保存到字典中
            obj.tree_type = tree_type
        return obj  # 有该类型的树木，则直接返回该类型对象

    def __init(self, size):
        self.size = size

    def render(self, age, x, y):
        print('render a tree of type {} and age {} at ({},{})'.format(self.tree_type, age, x, y))

 

第二步:生成十棵苹果树、三棵樱桃树、五棵桃树

import random


def main():
    rnd = random.Random()
    age_min, age_max = 1, 30
    min_piont, max_point = 0, 100
    tree_counter = 0

# 随机生成十棵苹果树
    for _ in range(10):
        t1 = Tree(TreeType.apple_tree)
        t1.render(rnd.randint(age_min, age_max),
                  rnd.randint(min_piont, max_point),
                  rnd.randint(min_piont, max_point)
                  )
        tree_counter += 1

# 随机生成三棵樱桃树
    for _ in range(3):
        t1 = Tree(TreeType.cherry_tree)
        t1.render(rnd.randint(age_min, age_max),
                  rnd.randint(min_piont, max_point),
                  rnd.randint(min_piont, max_point)
                  )
        tree_counter += 1

# 随机生成五棵桃子树
    for _ in range(5):
        t1 = Tree(TreeType.peach_tree)
        t1.render(rnd.randint(age_min, age_max),
                  rnd.randint(min_piont, max_point),
                  rnd.randint(min_piont, max_point)
                  )
        tree_counter += 1

    print(Tree.pool)


if __name__ == '__main__':
    main()

输出结果

render a tree of type TreeType.apple_tree and age 9 at (71,37)
render a tree of type TreeType.apple_tree and age 1 at (77,24)
render a tree of type TreeType.apple_tree and age 18 at (60,100)
render a tree of type TreeType.apple_tree and age 28 at (27,44)
render a tree of type TreeType.apple_tree and age 6 at (5,79)
render a tree of type TreeType.apple_tree and age 7 at (79,80)
render a tree of type TreeType.apple_tree and age 19 at (8,35)
render a tree of type TreeType.apple_tree and age 8 at (82,76)
render a tree of type TreeType.apple_tree and age 23 at (58,89)
render a tree of type TreeType.apple_tree and age 17 at (22,7)
render a tree of type TreeType.cherry_tree and age 1 at (1,70)
render a tree of type TreeType.cherry_tree and age 30 at (97,96)
render a tree of type TreeType.cherry_tree and age 12 at (23,23)
render a tree of type TreeType.peach_tree and age 6 at (22,95)
render a tree of type TreeType.peach_tree and age 3 at (39,78)
render a tree of type TreeType.peach_tree and age 24 at (84,23)
render a tree of type TreeType.peach_tree and age 10 at (42,60)
render a tree of type TreeType.peach_tree and age 12 at (85,89)
{
<TreeType.apple_tree: 1>: <__main__.Tree object at 0x7f805593d7c0>, 
<TreeType.cherry_tree: 2>: <__main__.Tree object at 0x7f805593d760>, 
<TreeType.peach_tree: 3>: <__main__.Tree object at 0x7f80559531f0>
}

 

 

 

三、享元模式的优缺点和适用场景

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

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

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

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