13. 设计模式-享元模式

定义

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

适用场景

例如，数据库链接，线程的建立开销都比较大，而且建立频率也很是高，所以就须要用到数据库链接池技术和线程池技术来共享数据库链接和线程。再例如，应用系统中一般存在最多的就是字符串，而且每每会大量重复，若是每次都建立新的字符串，可能会致使内存溢出、GC阻塞等性能问题，所以也就有了字符串驻留池技术。应用场景虽然天差地别，可是不管哪种场景，每每都会具有以下两个特色：

• 系统会用到大量相同或类似的对象；
• 对象建立比较耗时。

目的

而享元模式正是为了应对上述问题，并达到以下两个目的而存在的：

• 减小建立对象的数量；
• 对象全局共享。

示例

其实，说到享元模式，咱们最早应该提到的就是活字印刷术，由于它就是享元模式在生活中的一种最佳实践。咱们知道，出版一本哪怕百万字的著做，其实经常使用汉字也不过三千多个，这其中会有大量重复。传统的雕版印刷，每次印刷都须要先花大量的时间刻雕版，而且还不能重复使用，可是活字印刷就将共享和复用的特色发挥到了极致，省去了大量的时间。

其实，这种例子生活中并不罕见，例如，图书馆借书，共享单车，共享雨伞，共享马扎等哪一个不是享元模式思想的体现？由于享元模式的核心思想正是共享。

咱们下面仍是以活字印刷举例，经过代码的方式来实现一个印刷HELLO WORLD的例子加以说明。

模式演进

首先，咱们先把字模刻出来：

public abstract class Typeface
{
    public abstract string Print();
}

public class DTypeface : Typeface
{
    public override string Print()
    {
        return "D";
    }
}

public class ETypeface : Typeface
{
    public override string Print()
    {
        return "E";
    }
}

...

上面是简单的示意，其余字母以此类推，表示一个个的字模。经过这些字模咱们就能够印刷出版了。

static void Main(string[] args)
{
    Typeface h = new HTypeface();
    Typeface e = new ETypeface();
    Typeface l = new LTypeface();
    Typeface o = new OTypeface();
    Typeface w = new WTypeface();
    Typeface r = new RTypeface();
    Typeface d = new DTypeface();

    Console.WriteLine($"{h.Print()}{e.Print()}{l.Print()}{l.Print()}{o.Print()} {w.Print()}{o.Print()}{r.Print()}{l.Print()}{d.Print()}");
}

可是很遗憾，虽然印刷成功了，可是这些字模并不能全局共享，说到底仍是一次性的，换一个地方还得从新建立一次。不过说到全局共享，咱们前面好像就有一种模式能够办到，没错，就是单例模式。咱们不妨先用单例模式试试看：

public class ETypeface : Typeface
{
    private static readonly Typeface _instance = new ETypeface();

    private ETypeface() { }

    public static Typeface Instance => _instance;

    public override string Print()
    {
        return "E";
    }
}

将每一个字模都实现成如上所示的单例，再看看调用的地方：

static void Main(string[] args)
{
    Console.WriteLine($"{HTypeface.Instance.Print()}" +
        $"{ETypeface.Instance.Print()}{LTypeface.Instance.Print()}" +
        $"{LTypeface.Instance.Print()}{OTypeface.Instance.Print()}");
}

印刷成功了，而且也全局共享了。不过中国汉字何其多，所有实现成单例，类爆炸了，一个系统中成千上万个单例，想一想均可怕。不过好在处理类爆炸咱们是有经验的，没错，就是合并：

public class TypefaceFactory
{
    private static readonly Typeface _h = new HTypeface();
    private static readonly Typeface _e = new ETypeface();
    private static readonly Typeface _l = new LTypeface();
    private static readonly Typeface _o = new OTypeface();

    public static Typeface H => _h;
    public static Typeface E => _e;
    public static Typeface L => _l;
    public static Typeface O => _o;
}

咱们额外定义一个类，把全部单例字模都合并进去，不过咱们这时静态属性若是还叫Instance就命名冲突了，直接以字母命名好了，这样咱们就把全部单例都消灭了。虽然有所改善，不过字模太多的问题依然严峻，由于这个类中会封装成千上万的字模，而且随时可能更改，这致使这个类极不稳定。不过好在全部字模都继承自同一个基类，所以，咱们能够用一个字典存储，而且经过一个静态方法获取字模：

public class TypefaceFactory
{
    private static readonly IDictionary<Type, Typeface> _typefaces 
        = new Dictionary<Type, Typeface>();

    public static Typeface GetTypeface<TTypeface>() where TTypeface : Typeface
    {
        Type type = typeof(TTypeface);
        if (_typefaces.ContainsKey(type))
        {
            return _typefaces[type];
        }

        Typeface typeface = Activator.CreateInstance(typeof(TTypeface)) as Typeface;
        _typefaces.Add(type, typeface);
        return typeface;
    }
}

这样的话就好多了，能够管理大量细粒度的对象，而且也能够全局共享了，知足了咱们的需求，不知你们有没有发现，这里很是像简单工厂模式，只不过这里用到了一个静态字典作缓存，并不是每次都全新建立对象，其实这就是享元模式。

UML类图

再来抽象一下，看看享元模式的类图：

• FlyweightFactory：享元工厂，用来建立并管理Flyweight对象
• Flyweight：享元类的基类或接口
• ConcreteFlyweight：具体的Flyweight子类
• UnsharedConcreteFlyweight：不须要共享的Flyweight子类

在本例中，UnsharedConcreteFlyweight并无用到，可是做为享元模式中的一个角色确实是存在的，只是不可共享而已。例如，字模中有规范汉字，也有非规范汉字，可是出版刊物必须使用规范汉字，而不能使用非规范汉字。不过，咱们软件开发中会较少用到，由于，既然用不到，就不必去实现了。

优缺点

优势

• 节省内存空间，由于全局共享一个或者少数几个对象而已；
• 提升效率，由于不用每次都进行费时的初始化操做。

缺点

增长了系统的复杂度，其实咱们经过线程池和数据库链接池就不难发现，确实复杂了不少。

改进

其实，到这里咱们并无结束，若是还记得单例模式的话，咱们知道这种实现是存在并发问题的，没错，既然一样是用静态字段作共享，那么这里一样存在这并发问题，不过这里并发的是一个代码段，而不是简单的一个字段，所以就不能简单的经过Lazy关键字解决了，这里必须使用双检锁：

public class TypefaceFactory
{
    private static readonly IDictionary<Type, Typeface> _typefaces 
        = new Dictionary<Type, Typeface>();

    private static readonly object _locker = new object();
    public static Typeface GetTypeface<TTypeface>() where TTypeface : Typeface
    {
        Type type = typeof(TTypeface);
        if (!_typefaces.ContainsKey(type))
        {
            lock (_locker)
            {
                if (!_typefaces.ContainsKey(type))
                {
                    Typeface typeface = Activator.CreateInstance(typeof(TTypeface)) as Typeface;
                    _typefaces.Add(type, typeface);
                }
            }
        }

        return _typefaces[type];
    }
}

好了，此次完美了。

不过呢，不知你们有没有疑惑，从上面演进步骤看，享元模式好像是单例模式和简单工厂模式的综合运用，为何享元模式会归类到结构型模式而不是建立型模式呢？其实，缘由很简单，从表面上看，好像享元模式的享元工厂也在负责建立对象，但实际上，享元模式最主要的目的是对象的管理而不是建立，例如，咱们还能够经过以下方式实现享元模式：

public class TypefaceFactory
{
    private static readonly IDictionary<string, Typeface> _typefaces
        = new Dictionary<string, Typeface>();


    private static readonly object _locker = new object();

    public static void SetTypeface(string key, Typeface typeface)
    {
        if (!_typefaces.ContainsKey(key))
        {
            lock (_locker)
            {
                if (!_typefaces.ContainsKey(key))
                {
                    _typefaces.Add(key, typeface);
                }
            }
        }
    }

    public static Typeface GetTypeface(string key)
    {
        if (_typefaces.ContainsKey(key))
        {
            return _typefaces[key];
        }

        return null;
    }
}

看到了吗？这里就把对象的建立交给了客户端完成，而享元工厂只负责对象的管理，并不负责对象建立了。

与单例模式的区别

• 享元模式是共享大量类的大量实例，而单例是一个类一个实例；
• 单例模式针对的是对象的建立，而享元模式针对的是对象的管理；
• 单例模式不能单首创建，而享元模式中的类能够单首创建。

与简单工厂模式的区别

• 享元模式在简单工厂模式的基础上加入了缓存；
• 简单工厂模式的做用仅仅是建立对象，而享元模式虽然也建立对象，但其主要做用是管理和共享对象。

总结

享元模式实现起来很是灵活，它更重要体现的是一种思想，它不只在生活中被普遍运用，在软件开发过程当中也被普遍运用。不妨把上述享元工厂再换一个场景，例如把静态字典换成Redis，再把GetTypeface方法换成高并发环境下的查询接口，再去看看执行流程。发现了吧？就是咱们天天都在写的代码。
用心发现，享元模式真的是无处不在！

源码连接
更多内容，欢迎关注公众号: