一. 世间万物皆为对象
从大学校园中拦住一个软件工程专业的学生,问他,什么是面向对象。他会告诉你,世间万物皆是对象。
世界之大,何止万物。上至宇宙星辰,下至细菌病毒。皆为对象。
女孩,吐气如兰,仍留淡淡余香。
男孩,闭眼陶醉,不亦乐乎。
此乃共享之妙也!
二. 对象爆炸
呼吸之间,分子无数。
每个分子皆为一对象,恐万台服务器之矩阵亦无可容。
奈何乎?
GOF 曰: 享元模式!
三. 何为享元模式
Flyweight : 次最轻量级的拳击选手。即粒度最小。
因此,享元模式的目的是采用共享技术解决大量细粒度对象的爆炸问题。
图:
四. 享元模式应用之QQ聊天
我们不妨假设QQ是在服务器端将每次的对话都抽象出来形成了一个类。于是代码如下:
class People { private string name; private int age; public string Name { get { return name; } } public int Age { get { return age; } set { age = value; } } public People(string name, int age) { this.name = name; this.age = age; } }class Chat { private People boy; private People girl; private string chatContent; public Chat(People p1, People p2) { this.boy = p1; this.girl = p2; } public string ChatContent { get { return chatContent; } set { chatContent = value; } } public People Boy { get { return boy; } } public People Girl { get { return girl; } } }若每次二者聊天时均将Chat实例化为一个对象,如下:
class Program { static void Main(string[] args) { People boy=new People("PrettyBoy",20); People girl=new People("BeautifulGirl",18); Chat chat = new Chat(boy, girl); chat.ChatContent = "I love you"; ChatServer.Send(chat); } }若如此,服务器就需要每次都去初始化一个对象,而当chatServer将此次聊天的记录发送给客户机之后,这个对象便成了垃圾对象。这样,每小时几百万的聊天次数,便有了几百万的对象垃圾。垃圾回收器GC便需要不停地去工作,回收对象。
这就对效率产生了极大的影响。于是,我们想办法,使用享元模式来解决这个问题。
两者聊天,他们的聊天方是不变的,因此,我们可以在服务器端去维护一个这样的Chat对象集合,如果该聊天对象已经存在,那么我们便重复去利用这个聊天对象。这样既减少了内存垃圾,又节省了创建对象的时间。
代码如下:
class FlyweightFactory { private IDictionary<string, Chat> cache = new Dictionary<string, Chat>(); private void Add(Chat c) { cache.Add(c.Boy.Name + "_" + c.Girl.Name, c); } public Chat GetChat(People boy , People girl) { if (!cache.ContainsKey(boy.Name + "_" + girl.Name)) { cache.Add(boy.Name + "_" + girl.Name, new Chat(boy, girl)); } return cache[boy.Name + "_" + girl.Name]; } }于是,从客户端访问该FlyweightFactory即可。
这样,便有效控制了对象的数量。
五. 享元模式的.NET Framework典型应用——String
(在这里麻烦请教一下各位,我想在Reflector中,看一下String赋值的具体代码,怎么找到呢?比如说string s=”111”;这一步的代码)
好,步入正题,让我们来看看享元模式在.NET Framework中的应用。
String 无论在.NET 还是 Java中,都是一个特殊的引用对象。
我们可以试想,出现了这样一段代码:
String s=”Hello world”;
String s1=”Hello world”;
那么是不是每次都要重新的去申请一块内存,然后去保存这个字符串呢?那么这样的话是不是会效率很低呢?因为我们知道,字符串在实际使用中往往都是非常短暂的。他们通常是被读出来之后,便直接展示给了客户。然后这个字符串的生命结束,变成垃圾。是不是很像我们刚才那个QQ聊天对象呢?
于是在.NET 和 Java中,String都被以不变模式来进行设计。
我们来简单的分析一下String的驻留机制:在CLR被加载之后,就会在SystemDomain的托管堆中去建立一个HashTable来维护String。
于是模拟代码如下:(伪代码)
Hashtable table; if (!table.Contains("Hello world")) { table.Add("Hello world", &(new String("Hello world"))); } return *(table["Hello world"]);代码写的有些乱,我来解释一下。
也就是说,我是在模拟一个string s=”Hello world”的过程。过程是,首先,他先去找Hashtable中目前是否存有Key为”Hello world”的项。如果不存在,那么就分配一块堆内存,存储这字符串,然后将地址作为Value,存储在Hashtable中。如果存在的话,那么便直接找到该字符串所对应的地址,然后取出地址中的值。
用一个Hashtable来控制String对象的数量。这次您明白了么?
六 . 享元模式的扩展——对象池的应用
我们之前说,无论是字符串还是Object对象,使用享元模式都是去检查该对象是否存在,只要存在,那么便去重复使用。
那么是否有这样一种情况呢?
在峰期时,大量的客户端去访问同一个服务器,这个时候,如果只有一个对象的话,会引起一定的并发问题。我的语言表述有些不大清楚。简单的说,就是每当一个对象被访问的时候,他必须将自身锁定,并且防止其他客户去引用至该对象。
如果这个时候,我们依然去只维护一个对象的话,便会让大量的客户端处于等待队列中。因此,我们需要靠维护一个对象池,允许在对象池中,维护一个类的多个对象。从而来实现一个服务器空间与客户端等待时间的均衡问题。
因此,曾经,我们是在Dictionary中去维护一个Value为Object的缓存。而如今,我们便需要在Dictionary中去维护一个Value为List<Object>的缓存。而这个List应当是限定数量的,能保存同一类型Object的数组。
代码如下:(参考蜡笔小王的<设计模式——基于C#的工程化实现及扩展>)
class ObjectCache { private static IDictionary<Type, Object> cache; static ObjectCache() { cache = new Dictionary<Type, Object>(); } public bool TryToGetObejct<T>(out T item, out bool increasable) where T : class,IPoolable, new() { TryToAddObject<T>(); return (cache[typeof(T)] as SizeRestrictedList<T>).Acquire(out item, out increasable); } private void TryToAddObject<T>() where T:class,IPoolable,new() { if (!cache.ContainsKey(typeof(T))) { cache.Add(typeof(T), new SizeRestrictedList<T>()); } } }public bool Acquire(out T item, out bool increasable) { increasable = cache.Count >= configuration.Max ? false : true; item = null; if (cache.Count <= 0) { return false; } foreach (T cacheItem in cache) { if (cacheItem != null && cacheItem.Unoccupied) { item = cacheItem; return true; } } return false; }七. 从微观到宏观——究竟多小才算Flyweight
我们上文说过,Flyweight是来解决细粒度对象的重用问题。那么我们去想想,究竟多小才算细粒度呢?
在上文中,我们一直在解决的都是对象的重用问题。那么我们向宏观方向去想一想。
爱因斯坦的相对论:世间万物都是相对的。没有什么是绝对大的,只有相对的小。那么我们来这样想。
我们是否可以重用一个模块,或者一个子系统呢?
八. 举一而反三—— 从享元到单例
其实,在一定意义上,我个人认为单例模式和享元模式的初衷是一样的。他们都是一个基于空间和性能的模式。他们都是要控制对象的数量,而且实现方式本质上有着一些类似,就是首先查询这个对象是否存在,然后返回这个对象。
那么从享元模式上的引申,我们就一样可以用到单例模式上了:
1. 我们可以不局限于单例,而是可以控制为多例。比如说:类似我前面对象池的目的
2. 单例只是对象么?我们一样可以把子系统和模块单例!
看看他们的不同:
应该说享元模式是单例模式的一个延伸。享元模式通过享元工厂来控制多个对象的单例化。而单例化解决的只是本身的单例问题!
九. 不要为模式而模式——何时才用享元
我一直觉得,模式不要乱用,乱用模式是学习的阶段,但是一旦在工作中,我们去乱用模式,那么可能会造成很惨的后果。
那么究竟何时应该用享元模式呢?
1. 系统中要有大量的对象,这才值得用享元模式。否则你去维护一张对象表,就不值得了。
2. 对象的创建是会消耗大量时间的过程,并且对象占用较大内存。如果不是,那就让系统去创建吧。
3. 在B/S的系统中,个人感觉享元的应用相对较少,Web的无状态,加之我们完全在客户端进行一系列的复杂逻辑,然后将之统一传递给Web服务器端,而不需要享元。享元主要应用还是在C/S及Winform的本地程序上较多。
其余的,比如,关于外蕴状态和内蕴状态究竟何种应该使用享元的问题,如果不满足情况,您也根本没有办法去使用享元。因此,我就不在这说那些蹩嘴的定义了。
十 . 享元总结
享元模式(Flyweight):运用共享技术有效地支持大量细粒度的对象。
不早了,该睡觉了,等会还要起床加班………
谢谢大家的关注,也希望大家多多指教!
重温设计模式(一)——享元模式(Flyweight)
最新推荐文章于 2020-08-23 14:22:32 发布