关闭

实现对象的复用——享元模式(Flyweight Pattern)

标签: 设计模式享元模式
356人阅读 评论(0) 收藏 举报
分类:

一、引言

在软件开发过程,如果我们需要重复使用某个对象的时候,如果我们重复地使用new创建这个对象的话,这样我们在内存就需要多次地去申请内存空间了,这样可能会出现内存使用越来越多的情况,这样的问题是非常严重,然而享元模式可以解决这个问题,下面具体看看享元模式是如何去解决这个问题的。

二、享元模式的详细介绍

在前面说了,享元模式可以解决上面的问题了,在介绍享元模式之前,让我们先要分析下如何去解决上面那个问题,上面的问题就是重复创建了同一个对象,如果让我们去解决这个问题肯定会这样想:“既然都是同一个对象,能不能只创建一个对象,然后下次需要创建这个对象的时候,让它直接用已经创建好了的对象就好了”,也就是说——让一个对象共享。不错,这个也是享元模式的实现精髓所在。

2.1 定义

介绍完享元模式的精髓之后,让我们具体看看享元模式的正式定义:

享元模式——运用共享技术有效地支持大量细粒度的对象。享元模式可以避免大量相似类的开销,在软件开发中如果需要生成大量细粒度的类实例来表示数据,如果这些实例除了几个参数外基本上都是相同的,这时候就可以使用享元模式来大幅度减少需要实例化类的数量。如果能把这些参数(指的这些类实例不同的参数)移动类实例外面,在方法调用时将他们传递进来,这样就可以通过共享大幅度地减少单个实例的数目。(这个也是享元模式的实现要领),然而我们把类实例外面的参数称为享元对象的外部状态,把在享元对象内部定义称为内部状态。具体享元对象的内部状态与外部状态的定义为:

内部状态:在享元对象的内部并且不会随着环境的改变而改变的共享部分

外部状态:随环境改变而改变的,不可以共享的状态。

2.2 享元模式实现

分析完享元模式的实现思路之后,相信大家实现享元模式肯定没什么问题了,下面以一个实际的应用来实现下享元模式。这个例子是:一个文本编辑器中会出现很多字母,使用享元模式去实现这个文本编辑器的话,会把每个字母做成一个享元对象。享元对象的内部状态就是这个字母,而字母在文本中的位置和字体风格等其他信息就是它的外部状态。下面就以这个例子来实现下享元模式,具体实现代码如下:

/// <summary>
    /// 客户端调用
    /// </summary>
    class Client
    {
        static void Main(string[] args)
        {
            
// 定义外部状态,例如字母的位置等信息
            int externalstate = 10;
            
// 初始化享元工厂
            FlyweightFactory factory = new FlyweightFactory();
 
            
// 判断是否已经创建了字母A,如果已经创建就直接使用创建的对象A
            Flyweight fa = factory.GetFlyweight("A");
            if (fa != null)
            {
                
// 把外部状态作为享元对象的方法调用参数
                fa.Operation(--externalstate);
            }
            
// 判断是否已经创建了字母B
            Flyweight fb = factory.GetFlyweight("B");
            if (fb != null)
            {
                fb.Operation(--externalstate);
            }
            
// 判断是否已经创建了字母C
            Flyweight fc = factory.GetFlyweight("C");
            if (fc != null)
            {
                fc.Operation(--externalstate);
            }
            
// 判断是否已经创建了字母D
            Flyweight fd= factory.GetFlyweight("D");
            if (fd != null)
            {
                fd.Operation(--externalstate);
            }
            else
            {
                Console.WriteLine("驻留池中不存在字符串D");
                
// 这时候就需要创建一个对象并放入驻留池中
                ConcreteFlyweight d = new ConcreteFlyweight("D");
                factory.flyweights.Add("D", d);
            }
 
            Console.Read();
        }
    }
 
    /// <summary>
    /// 享元工厂,负责创建和管理享元对象
    /// </summary>
    public class FlyweightFactory
    {
        
// 最好使用泛型Dictionary<string,Flyweighy>
        
//public Dictionary<string, Flyweight> flyweights = new Dictionary<string, Flyweight>();
        public Hashtable flyweights = new Hashtable();
 
        public FlyweightFactory()
        {
            flyweights.Add("A", new ConcreteFlyweight("A"));
            flyweights.Add("B", new ConcreteFlyweight("B"));
            flyweights.Add("C", new ConcreteFlyweight("C"));
        }
 
        public Flyweight GetFlyweight(string key)
        {
// 更好的实现如下
            
//Flyweight flyweight = flyweights[key] as Flyweight;
            
//if (flyweight == null)
            
//{
            
//    Console.WriteLine("驻留池中不存在字符串" + key);
            
//    flyweight = new ConcreteFlyweight(key);
            
//}
            
//return flyweight;
return flyweights[key] as Flyweight;
        }
    }
 
    /// <summary>
    ///  抽象享元类,提供具体享元类具有的方法
    /// </summary>
    public abstract class Flyweight
    {
        public abstract void Operation(int extrinsicstate);
    }
 
    
// 具体的享元对象,这样我们不把每个字母设计成一个单独的类了,而是作为把共享的字母作为享元对象的内部状态
    public class ConcreteFlyweight : Flyweight
    {
        
// 内部状态
        private string intrinsicstate ;
 
        
// 构造函数
        public ConcreteFlyweight(string innerState)
        {
            this.intrinsicstate = innerState;
        }
 
        /// <summary>
        /// 享元类的实例方法
        /// </summary>
        /// <param name="extrinsicstate">外部状态</param>
        public override void Operation(int extrinsicstate)
        {
            Console.WriteLine("具体实现类: intrinsicstate {0}, extrinsicstate {1}", intrinsicstate, extrinsicstate);
        }
    }

在享元模式的实现中,我们没有像之前一样,把一个细粒度的类实例设计成一个单独的类,而是把它作为共享对象的内部状态放在共享类的内部定义,具体的解释注释中都有了,大家可以参考注释去进一步理解享元模式。

2.3 享元模式的类图

看完享元模式的实现之后,为了帮助大家理清楚享元模式中各类之间的关系,下面给出上面实现代码中的类图,如下所示:


在上图中,涉及的角色如下几种角色:

抽象享元角色(Flyweight):此角色是所有的具体享元类的基类,为这些类规定出需要实现的公共接口。那些需要外部状态的操作可以通过调用方法以参数形式传入。

具体享元角色(ConcreteFlyweight):实现抽象享元角色所规定的接口。如果有内部状态的话,可以在类内部定义。

享元工厂角色(FlyweightFactory):本角色复杂创建和管理享元角色。本角色必须保证享元对象可以被系统适当地共享,当一个客户端对象调用一个享元对象的时候,享元工厂角色检查系统中是否已经有一个符合要求的享元对象,如果已经存在,享元工厂角色就提供已存在的享元对象,如果系统中没有一个符合的享元对象的话,享元工厂角色就应当创建一个合适的享元对象。

客户端角色(Client):本角色需要存储所有享元对象的外部状态。

注:上面的实现只是单纯的享元模式,同时还有复合的享元模式,由于复合享元模式较复杂,这里就不给出实现了。

三、享元模式的优缺点

分析完享元模式的实现之后,让我们继续分析下享元模式的优缺点:

优点:

  1. 降低了系统中对象的数量,从而降低了系统中细粒度对象给内存带来的压力。

缺点:

  1. 为了使对象可以共享,需要将一些状态外部化,这使得程序的逻辑更复杂,使系统复杂化。
  2. 享元模式将享元对象的状态外部化,而读取外部状态使得运行时间稍微变长。

四、使用场景

在下面所有条件都满足时,可以考虑使用享元模式:

  • 一个系统中有大量的对象;
  • 这些对象耗费大量的内存;
  • 这些对象中的状态大部分都可以被外部化
  • 这些对象可以按照内部状态分成很多的组,当把外部对象从对象中剔除时,每一个组都可以仅用一个对象代替
  • 软件系统不依赖这些对象的身份,

满足上面的条件的系统可以使用享元模式。但是使用享元模式需要额外维护一个记录子系统已有的所有享元的表,而这也需要耗费资源,所以,应当在有足够多的享元实例可共享时才值得使用享元模式。

注:在.NET类库中,string类的实现就使用了享元模式,更多内容可以参考字符串驻留池的介绍,同时也可以参考这个博文深入理解.NET中string类的设计——http://www.cnblogs.com/artech/archive/2010/11/25/internedstring.html

五、总结

到这里,享元模式的介绍就结束了,享元模式主要用来解决由于大量的细粒度对象所造成的内存开销的问题,它在实际的开发中并不常用,可以作为底层的提升性能的一种手段。

0
0
查看评论
发表评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场

设计模式(结构型)之享元模式(Flyweight Pattern)

当一个软件系统在运行时产生的对象数量太多,将导致运行代价过高,带来系统性能下降等问题。所以需要采用一个共享来避免大量拥有相同内容对象的开销。在Java中,String类型就是使用了享元模式。Strin...
  • yanbober
  • yanbober
  • 2015-05-04 14:15
  • 2934

浅谈JAVA设计模式之——享元模式(Flyweight)

一、概述 运用共享技术有效地支持大量细粒度的对象。 二、适用性 当都具备下列情况时,使用Flyweight模式:        1.一个应用程序使用了大量的对象。       ...
  • l1028386804
  • l1028386804
  • 2015-05-07 23:46
  • 1578

Android设计模式之享元模式(Flyweight Pattern)

一 享元模式介绍:1.1 使用享元模式有什么好处? 享元模式是对象池的一种实现,主要目的是用来尽可能减少内存使用量。适合于存在大量重复对象的场景,来缓存可共享的对象,达到对象共享,避免创建过多对象...
  • happy_horse
  • happy_horse
  • 2016-04-14 15:56
  • 910

浅谈Java设计模式(十二)享元模式(Flyweight)

前言: 享元模式的主要目的是实现对象的共享,即共享池,当系统中对象多的时候可以减少内存的开销,通常与工厂模式一起使用。 FlyWeightFactory负责创建和管理享元单元,当一...
  • caihongdao123
  • caihongdao123
  • 2016-07-11 10:02
  • 2337

C++设计模式13----Flyweight享元模式

Flyweight享元模式概述 作用:运用共享技术有效地支持大量细粒度的对象。 内部状态intrinsic和外部状态extrinsic: 1)Flyweight模式中,最重要的是将对象分解成intri...
  • gatieme
  • gatieme
  • 2015-02-09 20:46
  • 12033

PHP设计模式——享元模式

声明:本系列博客参考资料《大话设计模式》,作者程杰。         享元模式使用共享物件,用来尽可能减少内存使用量以及分享资讯给尽可能多的相似物件;它适合用于只是因重复而导致使用无法令人接受的大量内...
  • jhq0113
  • jhq0113
  • 2015-05-16 13:06
  • 1751

实现对象的复用——享元模式(五):单纯、复合享元模式,享元模式总结

14.5 单纯享元模式和复合享元模式标准的享元模式结构图中既包含可以共享的具体享元类,也包含不可以共享的非共享具体享元类。但是在实际使用过程中,我们有时候会用到两种特殊的享元模式:单纯享元模式和复合享...
  • will130
  • will130
  • 2016-02-16 16:04
  • 525

JAVA设计模式之享元模式

解释一下概念:也就是说在一个系统中如果有多个相同的对象,那么只共享一份就可以了,不必每个都去实例化一个对象。比如说一个文本系统,每个字母定一个对象,那么大小写字母一共就是52个,那么就要定义52个对象...
  • jason0539
  • jason0539
  • 2014-04-04 07:34
  • 30969

23种设计模式之_享元模式

一什么是享元模式 二享元模式几个角色抽象享元类Flyweight 具体享元类FlyWeightAImlFlyWeightBIml 享元工厂类FlyweightFactoiy 客户类Client 三享元...
  • o279642707
  • o279642707
  • 2017-02-07 16:01
  • 481

实现对象的复用--享元模式(Flyweight)

(转自:http://blog.csdn.net/lovelion/article/details/7667781)1 围棋棋子的设计Sunny软件公司欲开发一个围棋软件,其界面效果如图14-1所示:...
  • cds86333774
  • cds86333774
  • 2016-03-22 19:25
  • 242
    个人资料
    • 访问:303439次
    • 积分:4521
    • 等级:
    • 排名:第7621名
    • 原创:150篇
    • 转载:93篇
    • 译文:0篇
    • 评论:38条
    最新评论
    我的小窝