12 享元模式

原文转载:https://blog.csdn.net/sinat_21107433/article/details/102763849

知道围棋吗?不会下围棋那总见过吧?四四方方的棋盘上,白色棋子和黑色棋子分布在棋盘的各个位置上。

棋子与棋子之间的区别是什么?除了颜色和位置,好像没什么不同了吧!也就是说,每个棋子对象的大部分状态都是一样的(形状、材料、质地等)。如果我们要设计一个程序来实现下围棋的功能,该如何来创建或者表示这上百个棋子对象呢?

类似的,你想输入一段英文段落,无论每个单词再长再复杂,也无非都是由26个字母中的几个组成的。上述两个示例的共同点在于,整个环境中存在大量相同或者相似的、需要重复使用的对象。针对这样的场景,面向对象设计中有一类值得借鉴的设计模式是不错的解决方案——享元模式。

1.享元模式简介

如果一个系统在运行时创建太多相同或者相似的对象,会占用大量内存和资源,降低系统性能。享元模式通过共享技术实现相同或相似的细粒度对象的复用,提供一个享元池存储已经创建好的对象,并通过享元工厂类将享元对象提供给客户端使用

享元模式:
运用共享技术有效地支持大量细粒度对象的复用。

享元模式要求被共享的对象必须是细粒度对象。如上面提到的输入英文段落的例子,26个字母可能随时被客户重复使用。尽管每个字母可能出现的位置不一样,但在物理上它们共享同一个对象(同一个实例)。利用享元模式,可以创建一个存储26个字母对象的享元池,需要时从享元池中取出。

享元对象能够做到共享的关键在于区分了内部状态和外部状态:

  • 内部状态:存储在享元对象内部,不会随着环境的改变而改变的,内部状态可以共享。比如围棋中棋子的形状、大小,不会随着外部变化而变化;比如字母A,无论谁使用,都是A,不会变化;
  • 外部状态:随环境变化而变化、不可以共享的状态,如棋子的位置、颜色,如每个字母的位置。外部状态一般由客户端保存,在使用时再传入到享元对象内部。不同的外部状态之间是相互独立的,棋子A和棋子B的位置可以不同,并且不会相互影响。

2.享元模式结构

享元模式常常结合工厂模式一起使用,其结构包含抽象享元类、具体享元类、非共享具体享元类和享元工厂类:

  • Flyweight(抽象享元类):是一个抽象类,声明了具体享元类公共的方法,这些方法可以向外部提供享元对象的内部状态数据,也可以通过这些方法设置外部状态;
  • ConcreteFlyweight(具体享元类):具体实现抽象享元类声明的方法,具体享元类中为内部状态提供存储空间。具体享元类常常结合单例模式来设计实现,保证每个享元类对象只被创建一次,为每个具体享元类提供唯一的享元对象
  • UnsharedConcreteFlyweight(非共享具体享元类):并不是所有抽象享元类的子类都需要被共享,可以将这些类设计为非共享具体享元类;
  • FlyweightFactory(享元工厂类):用于创建并管理享元对象,针对抽象享元类编程,将各种具体享元类对象存储在一个享元池中,享元池一般设计为一个存储键值对的集合(或者其他类型的集合),可结合工厂模式设计。客户需要某个享元对象时,如果享元池中已有该对象实例,则返回该实例,否则创建一个新的实例,给客户返回新的实例,并将新实例保存在享元池中。

3.享元模式代码实例

很多网络设备都是支持共享的,如交换机(switch)、集线器(hub)等。多台中断计算机可以连接同一台网络设备,并通过网络设备进行数据转发。本节Jungle将使用享元模式来模拟共享网络设备的实例。

本例中,交换机(switch)和集线器(hub)是具体享元对象。UML图如下所示:

3.1.抽象享元类

 
  1. // 抽象享元类

  2. class NetDevice

  3. {

  4. public:

  5. NetDevice(){}

  6. virtual string getName() = 0;

  7.  
  8. void print(){

  9. printf("NetDevice :%s\n",getName().c_str());

  10. }

  11. };

3.2.具体享元类

具体享元类有集线器和交换机,实现了抽象享元类声明的方法。

 
  1. // 具体享元类:集线器

  2. class Hub :public NetDevice

  3. {

  4. public:

  5. Hub(){}

  6. string getName(){

  7. return "集线器";

  8. }

  9. };

  10.  
  11. // 具体享元类:交换机

  12. class Switch :public NetDevice

  13. {

  14. public:

  15. Switch(){}

  16. string getName(){

  17. return "交换机";

  18. }

  19. };

3.3.享元工厂类

享元工厂类采用了单例模式,保证工厂实例的唯一性。采用一个vector作为共享池。

 
  1. // 享元工厂类

  2. class NetDeviceFactory

  3. {

  4. public:

  5. NetDevice* getNetDevice(char ch){

  6. if (ch == 'S'){

  7. return devicePool[1];

  8. }

  9. else if (ch == 'H'){

  10. return devicePool[0];

  11. }

  12. else{

  13. printf("wrong input!\n");

  14. }

  15. return NULL;

  16. }

  17.  
  18. // 单例模式:返回享元工厂类的唯一实例

  19. static NetDeviceFactory* getFactory(){

  20. if (instance == NULL){

  21. m_mutex.lock();

  22. if (instance == NULL){

  23. instance = new NetDeviceFactory();

  24. }

  25. m_mutex.unlock();

  26. }

  27. return instance;

  28. }

  29.  
  30. private:

  31. NetDeviceFactory(){

  32. Hub *hub = new Hub();

  33. Switch *switcher = new Switch();

  34. devicePool.push_back(hub);

  35. devicePool.push_back(switcher);

  36. }

  37. static NetDeviceFactory* instance;

  38. static std::mutex m_mutex;

  39.  
  40. // 共享池:用一个vector来表示

  41. vector<NetDevice*> devicePool;

  42. };

  43.  
  44. NetDeviceFactory* NetDeviceFactory::instance = NULL;

  45. std::mutex NetDeviceFactory::m_mutex;

3.4.客户端代码示例

 
  1. #include <iostream>

  2. #include "FlyweightPattern.h"

  3.  
  4. int main()

  5. {

  6. NetDeviceFactory *factory = NetDeviceFactory::getFactory();

  7.  
  8. NetDevice *device1, *device2, *device3, *device4;

  9.  
  10. // 客户端1获取一个hub

  11. device1 = factory->getNetDevice('H');

  12. device1->print();

  13. // 客户端2获取一个hub

  14. device2 = factory->getNetDevice('H');

  15. device2->print();

  16. // 判断两个hub是否是同一个

  17. printf("判断两个hub是否是同一个:\n");

  18. printf("device1:%p\ndevice2:%p\n", device1, device2);

  19.  
  20. printf("\n\n\n\n");

  21. // 客户端3获取一个switch

  22. device3 = factory->getNetDevice('S');

  23. device3->print();

  24. // 客户端4获取一个switch

  25. device4 = factory->getNetDevice('S');

  26. device4->print();

  27. // 判断两个switch是否是同一个

  28. printf("判断两个switch是否是同一个:\n");

  29. printf("device3:%p\ndevice4:%p\n", device3, device4);

  30.  
  31. printf("\n\n");

  32.  
  33. system("pause");

  34. return 0;

  35. }

客户端代码中,两个客户端分别获取集线器,Jungle打印出两个集线器的地址,来判断是否是同一个对象。同理,对交换机,Jungle也进行类似的判断。 

3.5.效果

由测试结果可以看出,两个集线器对象的地址是相同的,说明它们都是同一个实例对象,两个交换机也都指向同一个交换机实例对象。由此说明本例的代码实现了网络设备的共享。 

3.6.有外部状态的享元模式

进一步,尽管不同的终端计算机可能会共享同一个集线器(交换机),但是每个计算机接入的端口(port)是不一样的,端口就是每个享元对象的外部状态 在享元模式的使用过程中,内部状态可以作为具体享元类的成员对象,而外部状态可以通过外部注入的方式添加到具体享元类中

“通过外部注入”,因此,客户端可以通过函数传参的方式将“端口”号注入具体享元类:

 
  1. // 抽象享元类

  2. class NetDevice

  3. {

  4. public:

  5. NetDevice(){}

  6. virtual string getName() = 0;

  7.  
  8. /*void print(){

  9. printf("NetDevice :%s\n",getName().c_str());

  10. }*/

  11. void print(int portNum){

  12. printf("NetDevice :%s port: %d\n", getName().c_str(), portNum);

  13. }

  14. };

那么客户端的使用方式将变为:

 
  1. #include <iostream>

  2. #include "FlyweightPattern.h"

  3.  
  4. int main()

  5. {

  6. NetDeviceFactory *factory = NetDeviceFactory::getFactory();

  7.  
  8. NetDevice *device1, *device2, *device3, *device4;

  9.  
  10. // 客户端2获取一个hub

  11. device1 = factory->getNetDevice('H');

  12. device1->print(1);

  13. // 客户端2获取一个hub

  14. device2 = factory->getNetDevice('H');

  15. device2->print(2);

  16. // 判断两个hub是否是同一个

  17. printf("判断两个hub是否是同一个:\n");

  18. printf("device1:%p\ndevice2:%p\n", device1, device2);

  19.  
  20. printf("\n\n\n\n");

  21. // 客户端3获取一个switch

  22. device3 = factory->getNetDevice('S');

  23. device3->print(1);

  24. // 客户端4获取一个hub

  25. device4 = factory->getNetDevice('S');

  26. device4->print(2);

  27. // 判断两个hub是否是同一个

  28. printf("判断两个switch是否是同一个:\n");

  29. printf("device3:%p\ndevice4:%p\n", device3, device4);

  30.  
  31. printf("\n\n");

  32.  
  33. system("pause");

  34. return 0;

  35. }

 效果如下:

4.总结

优点

  • 享元模式通过享元池存储已经创建好的享元对象,实现相同或相似的细粒度对象的复用,大大减少了系统中的对象数量,节约了内存空间,提升了系统性能
  • 享元模式通过内部状态和外部状态的区分,外部状态相互独立,客户端可以根据需求任意使用。

缺点

  • 享元模式需要增加逻辑来取分出内部状态和外部状态,增加了编程的复杂度;

适用环境:

  • 当一个系统中有大量重复使用的相同或相似对象时,使用享元模式可以节约系统资源;
  • 对象的大部分状态都可以外部化,可以将这些状态传入对象中。
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值