在实际项目中,很多地方都存在IO。
而IO是很耗时间的,比方说:new、malloc。
对于现代的计算机来说,动辄就是GHz量级的主频,似乎感觉不到影响。但是在大型的项目里面,反复的new和delete,不仅会耗大量的时间,还会造成内存碎片。
new是一个很麻烦的东西。
有new的地方,就是你可能栽坑的地方。
new出的内存,没有被正确释放掉,会造成内存泄漏。微不足道的内存泄漏,在经过长时间积累,也会让你的程序崩溃。
学会内存管理,是C++程序员必须具备的能力。
接下来,我在这里实现一个简单的内存池。
这个内存池并不能与STL的内存池媲美。STL的内存池的实现更复杂,当然,它完成的功能也更强大。但是其实质是相同的。这个简单的内存池会使用到模版。
需要的知识点:
C++基本语法:reinterpret_cast(para)
数据结构:链表
C++泛型编程:模板
操作系统:临界区、锁
placement new (这个需要自己去看 C++ Primer)
好了,现在开始:
实践基础要点之一:reinterpret_cast(para)
看reinterpret_cast(para)的字面意思:重新解释。好深奥的词,怎么解释?《C++ Primer》一书中,对此的解释也甚少。
我之前也是不懂的,但是后来看多了,有点感觉。我的理解是:用新的expr结构,重新解释。
在下面的代码中,我们将看到
pHead = *(reinterpret_cast(pHead))
事实上,pHead 是T* 类型的。用reinterpret_cast把T*结构的pHead,强制转换成T**结构,然后对T**结构进行*操作符。怎么样,很暴力吧。之后结合代码再解释。
实践基础要点之二:数据结构:链表
对于所有的程序员来说,熟悉基本的数据结构必须是必备的技能。常听大牛们讲:基础决定了你能爬多高。想想也是,万丈高楼平地起嘛。我大二学习数据结构的时候,完全不知道老师在讲台上一个人唾沫横飞有什么意思,完全听不懂他在讲什么。到了考试临近的时候,拼命啃书,慢慢才对数据结构讲的是什么有些眉目。好了,回到正题。
所谓链表,就是有一个头结点H,该节点指向它的下一个节点NodeA,而NodeA又指向自己的下一个节点NodeB……一直到最后的节点指向NULL。这样,就连成了串,俗称链表。
举例说吧:
typedef struct Node
{
int _content;
Node* next;
}
Node* pHead; // define a head of a LinkList
Node* pNode; // define another node
pHead->next = pNode; // the head point to another node.
上面的代码只是简单的示例,省略了初始化部分,实际操作时候切不可这样写。
实践基础要点之三:C++泛型编程:模板
以模板的基础的应用的典型例子就是STL了,因为如此,我们才能方便的使用vector、list、map等容器。STL已经成为了C++重要的库之一了,在工程上运用得很多。这种无视类型的定义,增强了代码可复用性。在网络编程中,模版的作用必不可少噢。
模板在《C++ Primer》一书中,做了非常详细的讲解。模板函数,模板类。不了解的请仔细阅读该书的泛型编程部分。
实践基础要点之四:操作系统:临界区、锁
现代计算机的硬件已经很牛逼了,多核,多线程。为了充分发挥处理器的作用,在实际工程中,多线程技术已经相当成熟。但是,在多线程操作的时候,线程A对某共享数据进行写操作,而同时线程B也要多相同的共享数据进行写操作,如果没有控制好,共享数据就成了脏数据。这时候该怎么办。解决办法很多种,锁,互斥变量,信号量,临界区。在Windows下,系统提供了一套api,来处理这些。我们需要用到
InitializeCriticalSection(CRITICAL_SECTION*); // 初始化临界区
DeleteCriticalSection(CRITICAL_SECTION*); // 释放临界区
EnterCriticalSection(CRITICAL_SECTION*); // 进入临界区
LeaveCriticalSection(CRITICAL_SECTION*); // 离开临界区
其中: CRITICAL_SECTION是Windows所定义的临界区结构。我们不用去深究,只要明白它的作用就OK。
整个处理共享区域的流程,应该像这样:
共享数据Data在初始化时候,就声明并初始化一个临界区结构,在线程A对共享数据Data操作时候,让Data进入临界区域,然后操作。这样,线程B就无法对Data进行写操作了。操作完成,让Data离开临界区域。线程B这个时候才可以对Data进行写操作。在Data析构的时候,释放临界区域。
介绍完这些知识点,下面是应该上代码的时候了。在命名上,我们把临界区取个别名:锁。
定义临界区(因为要使用到Windows的API函数,记得包含Windows.h)
class CBaseLock
{
public:
CBaseLock()
{
InitializeCriticalSection(&m_sect);
}
~CBaseLock()
{
DeleteCriticalSection(&m_sect);
}
void Lock()
{
EnterCriticalSection(&m_sect);
}
void Unlock()
{
LeaveCriticalSection(&m_sect);
}
private:
CRITICAL_SECTION m_sect;
};
定义锁
template
class CLockImpl
{
public:
CLockImpl(T* l) : m_lock(l)
{
m_lock->Lock();
}
~CLockImpl()
{
m_lock->Unlock();
}
private:
T* m_lock;
};
定义内存池
template
class MyPool
{
public:
MyPool()
{
AllocatedCount = 0;
ElemSize = sizeof(T) > sizeof(T*) ? sizeof(T) : sizeof(T*);
pHead = NULL;
}
~MyPool()
{
while(pHead)
{
T* ret = pHead;
pHead = *(reinterpret_cast(pHead));
::free(ret);
}
}
int GetCount()const
{
return numAllocated;
}
T *alloc()
{
CLockImpl lock(&m_lock);
numAllocated++;
if(pHead == NULL)
return new(malloc(ElemSize))T;
T* ret = freeListHead;
pHead = *(reinterpret_cast(pHead));
return new(ret)T;
}
template
T *alloc(const T1& p)
{
CLockImpl lock(&m_lock);
numAllocated++;
if(pHead == NULL)
return new(malloc(ElemSize))T(p);
T* ret = pHead;
pHead = *(reinterpret_cast(pHead));
return new(ret)T(p);
}
template
template
……//这些情况我就不写了
void dealloc(T* elem)
{
elem->~T();
if(true)
{
CLockImpl lock(&m_lock);
memset(elem, 0xfe, elementSize);
--AllocatedCount;
*(reinterpret_cast(elem)) = pHead;
pHead = elem;
}
}
private:
int AllocatedCount; // 已经分配的内存节点个数
size_t ElemSize; // 内存节点的大小
T* pHead; // 空闲内存的链表表头
LockMode m_lock;
}
以上代码,基本完成了一个简单的内存池。
下面,对内存池中的一些重点语句进行解释。
构造函数
内存池初始化出来,是什么都没有的。因此,指向空闲内存区域的指针应指向NULL。而已分配的内存节点个数,当然必须是0。最最富有深意的,就应该是这句:
ElemSize = sizeof(T) > sizeof(T*) ? sizeof(T) : sizeof(T*);
其含义是,ElemSize的大小,应该是木板参数T与T*二者中较大的一个。(为什么要这么设计?往下看。)
public 接口 alloc()
对于内存池中的元素对象,若需要多个参数来初始化,就需要传入多个参数。这样,alloc()接口显然要满足多种情况,就需要把alloc()定义为模板函数,提供对应构造形参。而形参在内存池中,用模板参数指定,这样,调用alloc(),传入实参,就可以初始化元素,并为之分配内存了。
仔细看alloc()的实现,发现pHead指向空的时候,需要new一个ElemSize大小的空间。而pHead不为空的时候,就把pHead指向的空间返回。
pHead = *(reinterpret_cast(pHead));
pHead指向T*类型,然后把pHead用reinterpret_cast重新解释,这个时候,pHead指向的地址的空间(逻辑)结构就改变了。假设pHead指向ElemA类型, sizeof(ElemA) = 5,用reinterpret_cast重新解释,pHead指向就是指向指针的指针了。然后*reinterpret_cast就是向重新解释的地址区域取 值(取的是什么?继续往下看)。
析构
析构的时候,有这么一句:
*(reinterpret_cast(elem)) = pHead;
按照之前的解释,是把elem的地址用T**重新解释,然后取值,把pHead指向的地址放到该处。而pHead指向的地址,一定是比T和T*中,较大的一个的。32位操作系统下,T*是4字节,这说明pHead指向的地址,至少是4字节,至少足够容纳一个T**的类型。也就是说,我把elem这块内存的内容删除了,然后把这块地址分成若干4字节(32位系统下)的连续块,把pHead指向的第一个空闲地址块的地址放倒这块抵制块的第一个4字节中保存,然后pHead = elem; pHead指向elem的地址,则第一个空闲地址快就是刚刚释放了的elem的地址,elem地址中的第一个4字节保存了下一个空闲地址块的地址……如此链成链表。
然后又回到alloc上,alloc先检查有没有空闲地址,即pHead是否指向NULL,如果指向NULL,则new一块ElemSize大小的内存,在该内存中,用placement new技术,在申请的内存中,构造需要的元素对象。若pHead不指向NULL,则说明已经有申请好的内存(可能是某个对象析构之后,留下来,没有返还给系统的),取到pHead指向的第一块空闲内存块的地址,然后然pHead指向这块空闲地址质指向的空闲地址块(即 pHead = *(reinterpret_cast(pHead));这句的含义),然后构造元素对象。这样减少了想系统new的次数,节省了系统寻找合适大小内存块的时间,提高了效率。
加锁的原因,是因为防止多个线程,同时对某一对象内存池进行操作。
这样把简单的内存池解释了一遍。内存池的运行机制,大致是这样的。有些内存池会比这个内存池复杂得多。但是,理解了其中分配的要点,什么内存池都能玩得游刃有余。
总结:
内存池的存在,减少了系统IO次数,缩减了系统查找合适大小内存块的时间。提高了程序的运行效率,并有效减少了内存碎片的产生。
=====>THE END<=====