大内高手—惯用手法
转载时请注明出处:http://blog.csdn.net/absurd/
《POSA》中根据模式粒度把模式分为三类:架构模式、设计模式和惯用手法。其中把分层模式、管道过滤器和微内核模式等归为架构模式,把代理模式、命令模式和出版-订阅模式等归为设计模式,而把引用计数等归为惯用手法。这三类模式间的界限比较模糊,在特定的情况,有的设计模式可以作为架构模式来用,有的把架构模式也作为设计模式来用。
在通常情况下,我们可以说架构模式、设计模式和惯用手法,三者的重要性依次递减,毕竟整体决策比局部决策的影响面更大。但是任何整体都是局部组成的,局部的决策也会影响全局。惯用手法的影响虽然是局部的,其作用仍然很重要。它不但在提高软件的质量方面,而且在加快软件开发进度方面都有很大贡献。本文介绍几种关于内存的惯用手法,这些手法对于老手来说已经习以为常,对于新手来说则是必修秘技。
1. 预分配
假想我们实现了一个动态数组(vector)时,当向其中增加元素时,它会自动扩展(缩减)缓冲区的大小,无需要调用者关心。扩展缓冲区的大小的原理都是一样的:
l
先分配一块更大的缓冲区。
l
把数据从老的缓冲区拷贝到新的缓冲区。
l
释放老的缓冲区。
如果你使用realloc来实现,内存管理器可能会做些优化:如果老的缓冲区后面有连续的空闲空间,它只需要简单的扩展老的缓冲区,而跳过后面两个步骤。但在大多数情况下,它都要通过上述三个步骤来完成扩展。
以此可见,扩展缓冲区对调用者来说虽然是透明的,但决不是免费的。它得付出相当大的时间代价,以及由此产生的产生内存碎片问题。如果每次向vector中增加一个元素,都要扩展缓冲区,显然是不太合适的。
此时我们可以采用预分配机制,每次扩展时,不是需要多大就扩展多大,而是预先分配一大块内存。这一大块可以供后面较长一段时间使用,直到把这块内存全用完了,再继续用同样的方式扩展。
预分配机制比较常见,多见于一些带buffer的容器实现中,比如像vector和string等。
2. 对象引用计数
在面向对象的系统中,对象之间的协作关系非常复杂。所谓协作其实就调用对象的函数或者向对象发送消息,但不管调用函数还是发送消息,总是要通过某种方式知道目标对象才行。而最常见的做法就是保存目标对象的引用(指针),直接引用对象而不是拷贝对象,提高了时间和空间上的效率,也避免了拷贝对象的麻烦,而且有的地方就是要对象共享才行。
对象被别人引用了,但自己可能并不知道。此时麻烦就来了,如果对象被释放了,对该对象的引用就变成了野针,系统随时可能因此而崩溃。不释放也不行,因为那样会出现内存泄露。怎么办呢?
此时我们可以采用对象引用计数,对象有一个引用计数器,不管谁要引用这个对象,就要把对象的引用计数器加1,如果不再该引用了,就把对象的引用计数器减1。当对象的引用计数器被减为0时,说明没有其它对象引用它,该对象就可以安全的释放了。这样,对象的生命周期就得到了有效的管理。
对象引用计数运用相当广泛。像在COM和glib里,都是作为对象系统的基本设施之一。即使在像JAVA和C#等现代语言中,对象引用计数也是非常重要的,它是实现垃圾回收(GC)的基本手段之一。
代码示例: (atlcom.h: CcomObject)
STDMETHOD_
(
ULONG
,
AddRef
)() {
return
InternalAddRef
();}
STDMETHOD_
(
ULONG
,
Release
)()
{
ULONG
l
=
InternalRelease
();
if
(
l
== 0)
delete
this
;
return
l
;
}
|
3. 写时拷贝(COW)
OS内核创建子进程的过程是最常见而且最有效的COW例子:创建子进程时,子进程要继承父进程内存空间中的数据。但继承之后,两者各自有独立的内存空间,修改各自的数据不会互相影响。
要做到这一点,最简单的办法就是直接把父进程的内存空间拷贝一份。这样做可行,但问题在于拷贝内容太多,无论是时间还是空间上的开销都让人无法接受。况且,在大多数情况下,子进程只会使用少数继承过来的数据,而且多数是读取,只有少量是修改,也就说大部分拷贝的动作白做了。怎么办呢?
此时可以采用写时拷贝(COW),COW代表Copy on Write。最初的拷贝只是个假象,并不是真正的拷贝,只是把引用计数加1,并设置适当的标志。如果双方都只是读取这些数据,那好办,直接读就行了。而任何一方要修改时,为了不影响另外一方,它要把数据拷贝一份,然后修改拷贝的这一份。也就是说在修改数据时,拷贝动作才真正发生。
当然,在真正拷贝的时候,你可以选择只拷贝修改的那一部分,或者拷贝全部数据。在上面的例子中,由于内存通常是按页面来管理的,拷贝时只拷贝相关的页面,而不是拷贝整个内存空间。
写时拷贝(COW)对性能上的贡献很大,差不多任何带MMU的OS都会采用。当然它不限于内核空间,在用户空间也可以使用,比如像一些String类的实现也采用了这种方法。
代码示例(MFC:strcore.cpp):
拷贝时只是增加引用计数:
CString
::
CString
(
const
CString
&
stringSrc
)
{
ASSERT
(
stringSrc
.
GetData
()->
nRefs
!= 0);
if
(
stringSrc
.
GetData
()->
nRefs
>= 0)
{
ASSERT
(
stringSrc
.
GetData
() !=
_afxDataNil
);
m_pchData
=
stringSrc
.
m_pchData
;
InterlockedIncrement
(&
GetData
()->
nRefs
);
}
else
{
Init
();
*
this
=
stringSrc
.
m_pchData
;
}
}
|
修改前才拷贝:
void
CString
::
MakeUpper
()
{
CopyBeforeWrite
();
_tcsupr
(
m_pchData
);
}
void
CString
::
MakeLower
()
{
CopyBeforeWrite
();
_tcslwr
(
m_pchData
);
}
|
拷贝动作:
void
CString
::
CopyBeforeWrite
()
{
if
(
GetData
()->
nRefs
> 1)
{
CStringData
*
pData
=
GetData
();
Release
();
AllocBuffer
(
pData
->
nDataLength
);
memcpy
(
m_pchData
,
pData
->
data
(), (
pData
->
nDataLength
+1)*
sizeof
(
TCHAR
));
}
ASSERT
(
GetData
()->
nRefs
<= 1);
}
|
4. 固定大小分配
频繁的分配大量小块内存是内存管理器的挑战之一。
首先是空间利用率上的问题:由于内存管理本身的需要一些辅助内存,假设每块内存需要8字节用作辅助内存,那么即使只要分配4个字节这样的小块内存,仍然要浪费8字节内存。一块小内存不要紧,若存在大量小块内存,所浪费的空间就可观了。
其次是内存碎片问题:频繁分配大量小块内存,很容易造成内存碎片问题。这不但降低内存管理器的效率,同时由于这些内存不连续,虽然空闲却无法使用。
此时可以采用固定大小分配,这种方式通常也叫做缓冲池(pool)分配。缓冲池(pool)先分配一块或者多块连续的大块内存,把它们分成N块大小相等的小块内存,然后进行二次分配。由于这些小块内存大小是固定的,管理大开销非常小,往往只要一个标识位用于标识该单元是否空闲,或者甚至不需要任何标识位。另外,缓冲池(pool)中所有这些小块内存分布在一块或者几块连接内存上,所以不会有内存碎片问题。
固定大小分配运用比较广泛,差不多所有的内存管理器都用这种方法来对付小块内存,比如glibc、STLPort和linux的slab等。
5. 会话缓冲池分配(Session Pool)
服务器要长时间运行,内存泄露是它的威胁之一,任何小概率的内存泄露,都可能会累积到具有破坏性的程度。从它们的运行模式来看,它们总是不断的重复某个过程,而在这个过程中,又要分配大量(次数)内存。
比如像WEB服务器,它不断的处理HTTP请求,我们把一次HTTP请求,称为一次会话。一次会话要经过很多阶段,在这个过程要做各种处理,要多次分配内存。由于处理比较复杂,分配内存的地方又比较多,内存泄露可以说防不甚防。
针对这种情况,我们可以采用会话缓冲池分配。它基于多次分配一次释放的策略,在过程开始时创建会话缓冲池(Session Pool),这个过程中所有内存分配都通过会话缓冲池(Session Pool)来分配,当这个过程完成时,销毁掉会话缓冲池(Session Pool),即释放这个过程中所分配的全部内存。
因为只需要释放一次,内存泄露的可能大大降低。会话缓冲池分配并不是太常见,apache采用的这种用法。后来自己用过两次,感觉效果不错。
当然还有其一些内存惯用手法,如cache等,这里不再多说。上述部分手法在《实时设计模式》里有详细的描述,大家可以参考一下。
笔者水平有限,若遗漏了某些重要的内存惯用手法,还望各位高手补充。
~~~end~~
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=937803