23种设计模式----享元模式(FlyWeightPattern)

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

static void Main(string[] args)
{
    // 定义外部状态，例如字母的位置等信息
    int externalstate = 10;
    // 初始化享元工厂
    var 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");
        // 这时候就需要创建一个对象并放入驻留池中
        var d = new ConcreteFlyweight("D");
        factory.Flyweights.Add("D", d);
    }

    Console.Read();
}

public class FlyweightFactory {

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;
}

}

///
/// 抽象享元类，提供具体享元类具有的方法
///
public abstract class Flyweight
{
public abstract void Operation(int extrinsicstate);
}

// 具体的享元对象，这样我们不把每个字母设计成一个单独的类了，而是作为把共享的字母作为享元对象的内部状态
public class ConcreteFlyweight : Flyweight
{
// 内部状态
private readonly 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);
}

}

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

一个系统中有大量的对象；
这些对象耗费大量的内存；
这些对象中的状态大部分都可以被外部化
这些对象可以按照内部状态分成很多的组，当把外部对象从对象中剔除时，每一个组都可以仅用一个对象代替
软件系统不依赖这些对象的身份
满足上面的条件的系统可以使用享元模式。但是使用享元模式需要额外维护一个记录子系统已有的所有享元的表，而这也需要耗费资源，所以，应当在有足够多的享元实例可共享时才值得使用享元模式。

注：在.NET类库中，string类的实现就使用了享元模式，更多内容可以参考字符串驻留池的介绍，同时也可以参考这个博文深入理解.NET中string类的设计——通过内存分析工具来证明字符串驻留机制

优点：
降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

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

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