第18章 堆

18.1 进程的默认堆

（1）堆的特点

　　①不必考虑分配粒度和页面边界问题，但分配和释放内存的速度比其他方式慢

　　②堆是系统从页交换文件中预订的一块地址空间，系统会负责调拨和撤销调拨物理存储器。

（2）进程默认堆

　　①进程初始化时，系统会在进程地址空间中一个特殊的区域，这个区域为进程的默认堆（默认为1MB），也可以使用/HEAP链接器开关改变默认区域的大小，使用方法为/HEAP:reserve,[commit]

　　②许多Windows函数要用到默认堆，如ANSI版的Windows函数在底层必须先把ANSI字符串转为Unicode，再调用其Unicode版本（因为内核是Unicode版的）

　　③默认堆是进程私有的，不能为其他进程所共享。GlobalAllocLocalAlloc函数也是在默认堆是分配内存的。在使用剪贴板时要用GlobalAlloc从默认堆分配内存，在调用SetClipboardData时，系统会将该内存映射到进程高地址（内核分区），以便让其他进程可共享，这也就是调用GlobalAlloc时要指定为GMEM_MOVABLE的原因。

　　④对进程的默认堆的访问是串行化的。两个线程不能同时访问，只能等另一个线程结束对默认堆的访问之后才能访问（这可以防止堆被错误的分配和释放）。

　　⑤进程可以有多个堆，但默认堆只有一个。且默认堆的生命周期与进程一样，进程开始时由系统自动创建，进程结束时自动销毁。

（3）获取默认堆句柄的方法：HANDLE GetProcessHeap();

18.2 为什么要创建额外的堆

 

（1）对组件进行保护：（如图1所示）

　　①假设链表代表一个缺陷，不小心覆盖了NODE1后面的8个字节，从而破坏了BRANCH3结构体中的数据。BinTree.cpp中的代码后来在遍历二叉树时，可能因这个原因而失败。

　　②以上的错误，会造成一种假象，好象是BinTree.cpp代码出现错误，而实际上是ListList.cpp的代码有缺陷，这种错误很难跟踪与定位。

　　③可以创建两个独立的堆，一个用来保存Node结构，另一个用来保存Branch结构，这样可以使问题局部化。

（2）更有效的内存管理（如图2所示）

　　①假NODE结构为24字节，BRANCH为32字节，此时正好占满整个堆。如果释放NODE2和NODE4虽然可以回收48字节的空间，但会出现内存碎片，现在我们需要分配一个BRANCH结构时会出现失败。

　　②如果创建两个堆，每个堆只包含同样大小的对象，则可以避免上述现象。

（3）使内存访问局部化

　　①如果把内存的访问局限在一个较小的地址区间内，可以减少内存和磁盘之间的页面换入和换出操作，提高性能。

　　②程序设计时，可以在同一个堆中相邻的内存地址分配NODE对象，这样就可以尽可能把多个NODE对象放在同一个物理内存页中，遍历链表时，就可以减少访问太多的不同页面而导致页面的换入换出的交换操作。

　　③如果在同一个堆中分配了NODE和BRANCH对象且各个NODE对象都不相邻，极端情况下，设每个内存页只有一个NODE对象和BRANCH对象，这时遍历链表时可能会导致访问每个NODE都会引起页面错误，效率极低。

（4）避免线程同步的开销

　　①默认下对堆的访问是依次进行的。这样即使在同一时刻有多个线程要访问堆，也不会出现数据被破坏的情况，但堆函数要执行额外的堆的线程安全性保护的代码。

　　②如果创建一个新的堆，且该堆只会有一个线程会对其访问，这里可以给堆指定HEAP_NO_SERIALIZE属性，这样堆函数就不需执行额外的保护代码，从而提高了速度。

（5）快速释放

　　把一些数据结构存入一个专门的堆时，在不需要这些结构时，可以不必显式地释放堆中的每个内存块。而是可以直接销毁整个堆。

18.3 如何创建额外的堆

（1）创建私有堆的函数：HANDLE HeapCreate(fdwOptions,dwInitialSize,dwMaximumSize)

参数	含义
DWORD fdwOptions	新堆的可选属性，可以是下列的组合 ①0：默认 ②HEAP_NO_SERIALIZE：非独占地访问堆，不需要串行化。不指定该标志时，就是默认的独占访问。（该标志是线程不安全，不建议使用！）， ③HEAP_GENERATE_EXCEPTIONS：当在堆中分配或重新分配内存块失败时，执出一个异常，用于通知应用程序有错误发生。 ③HEAP_CREATE_ENABLE_EXCUTE：在堆中存放可执行代码，但需要在“数据执行保护”选项中启用DEP（详细可参考第13章）
SIZE_T dwInitialSize	初始化时，要调拨给堆的字节数。函数会将该值向上取整到CPU页面大小的整数倍。
SIZE_T dwMaximumSize	堆所能增长到的最大大小。如果设为0，表示没有上限。从堆中分配内存会使堆用尺所有的物理存储器为止。
返回值	返回新创建的私有堆的句柄。
备注：①默认下，调用Heap*函数，如果操作系统发现堆被破坏（如写内存时越界），这时在调试运行时会引发一个断言，但没有其他信息。 ②可以在堆管理器中进行设置，一旦Heap*函数发现堆破坏，就抛出一个异常，方法如下： HeapSetInformation(NULL,HeapEnableTerminationOnCorruption,NULL,0)。这个策略会应用到进程中所有的堆。而且一旦为进程所有的堆启用这个特性，就再也无法禁用它了。

（2）从堆中分配内存块：PVOID HeapAlloc(hHeap,fdwFlags,dwBytes)

参数	含义
HANDLE hHeap	堆的句柄，表示要从哪个堆中分配内存。
DWORD fdwFlags	HEAP_ZERO_MEMORY：把内存块内容清零 HEAP_GENERATE_EXECPTIONS：如果堆中没有足够内存，函数会抛出异常。如果内存不足时，会抛出STATUS_NO_MEMORY异常；如果堆被破坏或传入的参数不正确时，会抛出STATUS_ACCESS_VIOLATION异常。 HEAP_NO_SERIALIZE：强制系统不要把这次的HeapAlloc调用与其他线程对同一个堆的访问串行化。（可能破坏堆的完整性，慎用！）
SIZE_T dwBytes	要从堆中分配多少个字节
返回值	返回分配到的内存地址。
备注：①调用HeapCreate时可以传入HEAP_GENERATE_EXCEPTIONS标志，这时HeapAlloc可以不指定。如果在创建堆的时候没有指定这个标志，而是在调用HeapAlloc时指定的话，则这个标志只影响当前这次调用，而不会影响在这个堆上所有其他对HeapAlloc函数的调用。 ②在分配大块内存（1MB或更多）时，应避免使用堆函数，建议使用VirtualAlloc函数。 ③如果分配大小不同的内存块，可能很容易产生地址空间碎片化，我们可以强制系统在分配内存时使用一种低碎片堆的算法。(如果堆使用的是HEAP_NO_SERIALIZE创建，下列调用会失败)     ULONG iValue = 2; HeapSetInformation(hHeap,HeapCompatibilityInformation,&iVlaue,sizeof(iValue));

（3）调整内存块的大小：PVOID HeapReAlloc(hHeap,fdwFlags,pvMem,dwBytes)

参数	含义
HANDLE hHeap	需要调整大小的内存块所在的
DWORD fdwFlags	HEAP_GENERATE_EXCEPTIONS、HEAP_NO_SERIALIZE HEAP_ZERO_MEMORY：增大内存块是，额外的字节清0 HEAP_REALLOC_IN_PLACE_ONLY：增大内存块时，不会移动内存块。（这对于链表或树来说，有时很重要，因为节点可能包含指向当前节点指针，当被移到其他堆的其他地方时会破坏链表或树的完整性。
PVOID pvMem	要调整大小的内存块的当前地址
SIZE_T dwBytes	新的内存块的大小
返回值	返回新创建新的内存块的地址或NULL。
备注：如果不需要移动内存块的前提下增大内存块或把内存块减小时，函数会返回原来内存块的地址。如果必须移动内存块，函数会返回一个新的地址。

（4）获得内存块的大小：SIZE_T HeapSize(hHeap,fdwFlags,pvMem);//其中hHeap用来标识堆，参数pvMem表示内存块的地址。fdwFlags为0或HEAP_NO_SERIALIZE。

（5）释放内存块：BOOL HeapFree(hHeap,fdwFlags,pvMem);//各参数与HeapSize含义一样。这个函数可能会使堆管理器撤销一些己经调拨的物理存储器，但这并不是一定的。

（6）销毁堆：BOOL HeapDestroy(hHeap);

　　①该函数会释放堆中所有的内存块，同时回收占用的物理存储器和地址空间。

　　②进程的默认堆在进程结束时会自动销毁，如果手动调用来销毁则函数的调用会被忽略并返回FALSE

　　③其他私有堆在不用时，可以手动调用该函数来销毁。如果没有被销毁，在进程结束以后系统会替我们销毁。

【Heap程序】演示如何使用堆

#include <tchar.h>
#include <windows.h>
#include <time.h>
#include <stdio.h>

void PrintArray(float fArray[], int iCnt){
    for (int i = 0; i < iCnt;i++){
        printf("[%03d]=%0.0f	",i,fArray[i] );
    }
}

int _tmain(){
    srand((unsigned int)time(NULL));

    //在进程默认堆中申请内存
    HANDLE hHeap = GetProcessHeap();
    const int iCnt = 200;

    //申请fArray内存块
    float* fArray = (float*)HeapAlloc(hHeap, HEAP_ZERO_MEMORY, iCnt*sizeof(float));

    for (int i = 0; i < iCnt;i++){
        fArray[i] = 1.0f*rand();
    }
    //扩大fArray内存块的大小
    fArray = (float*)HeapReAlloc(hHeap, HEAP_ZERO_MEMORY, fArray, 2 * iCnt*sizeof(float));
    for (int i = iCnt; i < 2 * iCnt;i++){
        fArray[i] = 1.0f*rand();
    }
    //打印内存块（数组）的内容
    printf("Default Heap:
");
    PrintArray(fArray, 2 * iCnt);

    HeapFree(hHeap, 0, fArray);//释放内存块

    //创建私有堆
    hHeap = HeapCreate(HEAP_GENERATE_EXCEPTIONS, 0, 0);
    
    //申请内存块
    fArray = (float*)HeapAlloc(hHeap, HEAP_ZERO_MEMORY, iCnt*sizeof(float));
    for (int i = 0; i < iCnt;i++){
        fArray[i] = 1.0f*rand();
    }
    
    //扩大fArray内存块的大小
    fArray = (float*)HeapReAlloc(hHeap, HEAP_ZERO_MEMORY, fArray, 2 * iCnt*sizeof(float));
    for (int i = iCnt; i < 2 * iCnt; i++){
        fArray[i] = 1.0f*rand();
    }

    //打印内存块（数组）的内容
    printf("Additional Heap:
");
    PrintArray(fArray, 2 * iCnt);

    HeapFree(hHeap,0,fArray);
    HeapDestroy(hHeap);  //私有堆，要手动销毁

    return 0;

}

【CSomeClass程序】在C++中使用堆

#include <windows.h>
#include <stdio.h>

/*/////////////////////////////////////////////////////////////////////////
演示如何利用C++来使用的创建和销毁
//主要功能：
1、让同一个类的实例在同一个堆中分配空间
2、当使用计数s_uNumAllocsInHeap为0时，会自动销毁堆

//可能的问题
1、当考虑继承时，如果新类继承了new和delete操作符，则派生类也会从同一个堆中
   分配内存。这种情况有时是我们希望的，但也可能不是我们希望的，因为对象的大
   小可能相差非常大，那就可能在堆中造成严重的碎片
2、如果想在派生类中使用一个单独的堆，就可以在派生类中增加一组s_hHeap和
   s_uNumAllocsInHeap变量，同时把new和delete操作符的代码复制过去。这样就不会调用
   基类的操作符了。
/////////////////////////////////////////////////////////////////////////*/
class CSomeClass{
private:
    static HANDLE s_hHeap; //保存堆句柄，让同一个类的实例在同一个堆中分配空间
    static UINT s_uNumAllocsInHeap;//计数器，用来记录从堆中分配了多少个
                                   //CSomeClass对象，用来控制销毁堆
    //...其他私有变量和成员函数
    int iTest; //用于测试目的
public:
    void* operator new(size_t size); //重载new操作符
    void  operator delete(void* p);  //重载delete操作符

    //...其他的全局变量和函数
    //以下函数用于测试目的
    int GetTestValue(){ return iTest; }
    void SetTestValue(const int iValue){ iTest = iValue; }
    int GetCount(){ return s_uNumAllocsInHeap; }
};

HANDLE CSomeClass::s_hHeap = NULL; //静态变量初始化
UINT CSomeClass::s_uNumAllocsInHeap = 0;

//new操作符中的size编译器会帮我们传入，等于sizeof(CSomeClass)
void*  CSomeClass::operator new(size_t size){
    if (s_hHeap == NULL){
        //如果堆不存在，则创建
        //1、HEAP_NO_SERIALIZE表示这个类不支持多线程的
        //2、第2个参数为0，而不传入size。因为在这个堆中
        //   可能会创建多个类的对象和一些额外的空间。
        s_hHeap = HeapCreate(HEAP_NO_SERIALIZE, 0, 0);
        if (s_hHeap == NULL)
            return NULL;
    }

    //如果堆己经存在，则为对象分配空间大小
    void* p = HeapAlloc(s_hHeap, 0, size);

    if (p != NULL){
        s_uNumAllocsInHeap++; //计数加1    
    }

    return p;
}

void CSomeClass::operator delete(void* p){
    if (HeapFree(s_hHeap,0,p)){
        s_uNumAllocsInHeap--; //删除对象成功
    }

    if (s_uNumAllocsInHeap == 0){
        //堆中己经没有类的对象了
        if (HeapDestroy(s_hHeap)){
            s_hHeap = NULL; //设为NULL，下次再创建对象时会
                            //重新创建一个堆
        }
    }
}

int main(){    
    //编译器编译下面一行代码时，会检查到CSomeClass重载了new操作符
    //就会生成代码来调用这个成员函数，所以会执行函数里堆的创建等
    //操作，如果没有重载new，编译器将生成代码来调用C++标准的new操作符
    CSomeClass* pSome = new CSomeClass;
    
    pSome->SetTestValue(100);
    printf("在堆中分配了%d类实例对象
", pSome->GetCount());
    printf("sizeof(CSomeClass)=%d,iTest = %d
", sizeof(CSomeClass),pSome->GetTestValue());
   
    delete pSome;
    return 0;
}

18.4 其他堆函数

（1）获取进程中所有的堆（含默认堆）：GetProcessHeaps

　　①函数原型：DWORD GetProcessHeaps(dwNumHeaps,phHeaps);

　　②参数说明：dwHeaps要获得的堆数目，phHeaps数组用来接收返回的堆句柄。可用两个调用方法得到堆的数目，第1次dwCount = GetProcessHeaps(0, NULL);其中的dwCount就是进程中堆的数量。

（2）验证堆的完整性：HeapValidate函数

　　①函数原型：BOOL HeapValidate(hHeap,fdwFlags,pvMem)

　　②参数说明：fdwFlags只能传入0或HEAP_NO_SERIALIZE。如果pvMem指定为NULL，则函数会遍历堆中各个内存块，只有要一个内存块被破坏，就会返回FALSE。如果pvMem指定一个内存块的地址，则只检查这个内存块。

（3）合并闲置的内存块：（会同时撤销调拨给这些内存块的物理存储器）：HeapCompact

　　①函数原型：UINT HeapCompact(hHeap,fdwFlags);

　　②参数说明：fdwFlags只能传0或HEAP_NO_SERIALIZE标志。

（4）锁定和解锁堆：HeapLockHeapUnlock

　　①这两个函数用于线程同步，必须配对使用。

　　②HeapLock锁定堆时，其他线程调用堆函数（并且操作同一个堆）时将被系统挂起。HeapUnlock唤醒这些线程。

　　③为了确保对堆的访问是依次进行的，HeapAlloc、HeapSize、HeapFree这些函数的内部调用了HeapLock和HeapUnlock。所以我们不需要自己去调用HeapLock和HeapUnlock。

（5）遍历堆：HeapWalk(hHeap,pHeapEntry);

 

　　①遍历时，需多次调用这个函数，而且调用时必须分配并初始化一个PROCESS_HEAP_ENTRY结构（如上图所示），并将地址传给HeapWalk。

　　②开始枚举堆的内存块时，必须把该结构体的lpData成员设为NULL，这向HeapWalk表明要初始化结构体中的成员。

　　③每次成功调用heapWalk之后，可以查看结构成员来了解内存块的情况。

　　④要得到下一个内存块，必须再次调用HeapWalk，并传入和一上次调用时相同的堆句柄和PROCESS_HEAP_ENTRY结构体的地址。

　　⑤当HeapWalk返回FALSE时，表示堆中己经没有更多的内存块了。

　　⑥可以在HeapWalk循环的外部调用HeapLock和HeapUnlock函数，这个在遍历堆的时候，其他线程便无法操作这个堆。

 【HeapWalk程序】遍历进程中所有的堆，并显示堆中的内存分配信息

#include <tchar.h>
#include <windows.h>
#include <time.h>
#include <locale.h>

int _tmain(){
    _tsetlocale(LC_ALL, _T("chs"));

    srand((unsigned int)time(NULL));
    const int iCnt = 100;
    HANDLE hHeap = GetProcessHeap();
    void* pMem[iCnt];
    ZeroMemory(pMem, iCnt* sizeof(void*));

    //分配100个内存块，大小随机
    for (int i = 0; i < iCnt;i++){
        pMem[i] = HeapAlloc(hHeap, 0, 50/*rand() % iCnt*/);
    }

    PROCESS_HEAP_ENTRY phe = {};
    HeapLock(hHeap); //锁定堆

    int iBlock = 0;
    //遍历进程默认堆
    while (HeapWalk(hHeap,&phe)){
        ++iBlock;
    }
    HeapUnlock(hHeap);//释放堆

    _tprintf(_T("进程默认堆中共有%d个内存块
"),iBlock);
    //for (int i = 0; i < iCnt;i++){
    //    HeapValidate(hHeap, 0, pMem[i]);
    //
    //    _tprintf(_T("pMem[%d]=0x%08X is %s BlockSize=%d Bytes
"), i, pMem[i], 
    //                HeapValidate(hHeap, 0, pMem[i])? TEXT("Valid"):TEXT("InValid"),
    //                HeapSize(hHeap, 0, pMem[i]));
    //    HeapFree(hHeap, 0, pMem[i]);
    //}

    //下面的代码演示如何遍历一个进程中的所有的堆
    DWORD dwHeapCnt = 0;
    PHANDLE pHArray = NULL;
    dwHeapCnt = GetProcessHeaps(0, NULL);
    if (dwHeapCnt>0){
        pHArray = (PHANDLE)HeapAlloc(GetProcessHeap(), 0, dwHeapCnt*sizeof(HANDLE));
        GetProcessHeaps(dwHeapCnt, pHArray);
        for (DWORD i = 0; i < dwHeapCnt;i++){
            HeapLock(pHArray[i]);
            iBlock = 0;
            ZeroMemory(&phe, sizeof(PROCESS_HEAP_ENTRY));
            _tprintf(_T("堆[%p]中的内存分配情况：
"), pHArray[i]);
            while (HeapWalk(pHArray[i],&phe)){
                ++iBlock;
                
                _tprintf(_T("	块[%p]的信息，这里省略...
"),phe.lpData);
                //显示块信息，这里省略。。。
                //DisplayHeapInfo(phe); //每个内存块的信息放在phe的结构体中
            }
            _tprintf(_T("堆[%p]中共有%d个内存块

"),pHArray[i],iBlock);
            HeapUnlock(pHArray[i]);
        }
        HeapFree(GetProcessHeap(), 0, pHArray);
    }
    _tprintf(_T("本进程中共有%d个堆

"), dwHeapCnt);
    return 0;
}