设计模式之享元模式

享元模式（英语：Flyweight Pattern）是一种软件设计模式。它使用共享物件，用来尽可能减少内存使用量以及分享资讯给尽可能多的相似物件；

它适合用于只是因重复而导致使用无法令人接受的大量内存的大量物件。通常物件中的部分状态是可以分享。

常见做法是把它们放在外部数据结构，当需要使用时再将它们传递给享元。他与单例最大的特征就是单例的实例类是不允许在外部构建的，

但是享元模式可以，享元模式的适用场景很多，例如线程池，数据连接池，包括CLR就也调用它

现在我们先来实现享元模式，创建几个简单的类

 public class E : BaseWord
    {
        public E()
        {
            Thread.Sleep(1000);
            Console.WriteLine("字符E被构造");
        }

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

    public class L : BaseWord
    {
        public L()
        {
            Thread.Sleep(1000);
            Console.WriteLine("字符L被构造");
        }

        public override string Display()
        {
            return "L";
        }
  
    }

    public class N : BaseWord
    {
        public N()
        {
            Thread.Sleep(1000);
            Console.WriteLine("字符N被构造");
        }

        public override string Display()
        {
            return "N";
        }
    }

    public class V : BaseWord
    {
        public V()
        {
            Thread.Sleep(1000);//表明对象构造比较耗时
            Console.WriteLine("字符V被构造");
        }

        public override string Display()
        {
            return "V";
        }
    }

然后新建一个FlyweightPattern类

namespace 享元模式
{
    public class FlyweightPattern
    {
        private static Dictionary<WordType, BaseWord> _BaseWordDic = new Dictionary<WordType, BaseWord>();
        private static object GetWord_Lock = new object();

        public static BaseWord GetWord(WordType wordType)
        {
            BaseWord baseword = null;
            //双if+Lock
            if (_BaseWordDic.ContainsKey(wordType))
            {
                return _BaseWordDic[wordType];
            }
            else
            {
                lock (GetWord_Lock)
                {
                    if (_BaseWordDic.ContainsKey(wordType))
                    {
                        baseword = _BaseWordDic[wordType];
                    }
                    else
                    {
                        switch (wordType)
                        {
                            case WordType.E:
                                baseword = new E();
                                break;
                            case WordType.L:
                                baseword = new L();
                                break;
                            case WordType.V:
                                baseword = new V();
                                break;
                            case WordType.N:
                                baseword = new N();
                                break;
                            default:
                                throw new Exception("wrong wordType");
                        }
                    }
                    _BaseWordDic[wordType] = baseword;
                    return baseword;
                }
            }
        }
    }

    public enum WordType
    {
        E,
        L,
        V,
        N
    }
}

享元模式使用一个静态的字典来保存已经实例化出来的类的值，下次进来的时候会先判断字典，大大减少了创建实例的性能开销。

使用双if+lock，确保在多线程下也能正常的运行

然后我们写上这两个相同的方法来测试，使用异步的方法来调用

在多次调用该类时，不会被创建，而是通过享元模式更快的获得了想要的类的对象

接下来用另一个方法来说明享元模式，首先创建两个相同的变量，然后对它们作比较

两个字符串的值是相同的，经过这三种方法的比较之后，输出的都是True结果。

前两个比较是比较值，没什么问题，那么比较引用为什么也输出True呢，我们知道，内存在分配引用类型的时候，实际给的是一个引用地址，

这里明明有两个引用地址才对，为什么会输出相同呢？其实，这也就是CLR在给赋值的时候使用了享元模式

它也有一个静态字典，在每次赋值时就判断有没有这个值。如果有就取得相同的引用地址给它。

另外还有种特殊的情况，就是使用string.Format

这样输出的结果是True,True,Flase

从这里可以看出string.Form在申请内存的时候，只是申请了Big,然后后面留了个空内存，等待动态运行时改变了这个变量

所有它和A指向的不是一个引用地址