C++ stack memoryMalloc heap or stackC# Stack heapstack heap記憶體Increase heap size Visual Studio C++stack heap差異Stack heapc 中堆和棧的的區別（stack vs heap） | 程式前沿
文章推薦指數： 80 %
堆和棧的區別一、預備知識—程式的記憶體分配一個由c/C 編譯的程式佔用的記憶體分為以下幾個部分1、棧區（stack）— 由編譯器自動分配釋放， ...
程式語言前端開發IOS開發Android開發雲端運算人工智慧伺服器搜尋資料庫軟體開發工具c中堆和棧的的區別（stackvsheap）2018.06.13程式語言HOME程式語言c中堆和棧的的區別（stackvsheap）Advertisement堆和棧的區別一、預備知識—程式的記憶體分配一個由c/C編譯的程式佔用的記憶體分為以下幾個部分1、棧區（stack）—由編譯器自動分配釋放，存放函式的引數值，區域性變數的值等。
其操作方式類似於資料結構中的棧。
2、堆區（heap）—一般由程式設計師分配釋放，若程式設計師不釋放，程式結束時可能由OS回收。
注意它與資料結構中的堆是兩回事，分配方式倒是類似於連結串列，呵呵。
3、全域性區（靜態區）（static）—，全域性變數和靜態變數的儲存是放在一塊的，初始化的全域性變數和靜態變數在一塊區域，未初始化的全域性變數和未初始化的靜態變數在相鄰的另一塊區域。
–程式結束後有系統釋放4、文字常量區—常量字串就是放在這裡的。
程式結束後由系統釋放5、程式程式碼區—存放函式體的二進位制程式碼。
堆和棧的區別一、預備知識—程式的記憶體分配一個由c/C編譯的程式佔用的記憶體分為以下幾個部分1、棧區（stack）—由編譯器自動分配釋放，存放函式的引數值，區域性變數的值等。
其操作方式類似於資料結構中的棧。
2、堆區（heap）—一般由程式設計師分配釋放，若程式設計師不釋放，程式結束時可能由OS回收。
注意它與資料結構中的堆是兩回事，分配方式倒是類似於連結串列，呵呵。
3、全域性區（靜態區）（static）—，全域性變數和靜態變數的儲存是放在一塊的，初始化的全域性變數和靜態變數在一塊區域，未初始化的全域性變數和未初始化的靜態變數在相鄰的另一塊區域。
–程式結束後有系統釋放4、文字常量區—常量字串就是放在這裡的。
程式結束後由系統釋放5、程式程式碼區—存放函式體的二進位制程式碼。
二、例子程式這是一個前輩寫的，非常詳細//main.cppinta=0;全域性初始化區char*p1;全域性未初始化區main(){intb;棧chars[]="abc";棧char*p2;棧char*p3="123456";123456\0在常量區，p3在棧上。
staticintc=0；全域性（靜態）初始化區p1=(char*)malloc(10);p2=(char*)malloc(20);分配得來得10和20位元組的區域就在堆區。
strcpy(p1,"123456");123456\0放在常量區，編譯器可能會將它與p3所指向的"123456"優化成一個地方。
}二、堆和棧的理論知識2.1申請方式stack:由系統自動分配。
例如，宣告在函式中一個區域性變數intb;系統自動在棧中為b開闢空間heap:需要程式設計師自己申請，並指明大小，在c中malloc函式如p1=(char*)malloc(10);在C中用new運算子如p2=(char*)malloc(10);但是注意p1、p2本身是在棧中的。
2.2申請後系統的響應棧：只要棧的剩餘空間大於所申請空間，系統將為程式提供記憶體，否則將報異常提示棧溢位。
堆：首先應該知道作業系統有一個記錄空閒記憶體地址的連結串列，當系統收到程式的申請時，會遍歷該連結串列，尋找第一個空間大於所申請空間的堆結點，然後將該結點從空閒結點連結串列中刪除，並將該結點的空間分配給程式，另外，對於大多數系統，會在這塊記憶體空間中的首地址處記錄本次分配的大小，這樣，程式碼中的delete語句才能正確的釋放本記憶體空間。
另外，由於找到的堆結點的大小不一定正好等於申請的大小，系統會自動的將多餘的那部分重新放入空閒連結串列中。
2.3申請大小的限制棧：在Windows下,棧是向低地址擴充套件的資料結構，是一塊連續的記憶體的區域。
這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就確定的常數），如果申請的空間超過棧的剩餘空間時，將提示overflow。
因此，能從棧獲得的空間較小。
堆：堆是向高地址擴充套件的資料結構，是不連續的記憶體區域。
這是由於系統是用連結串列來儲存的空閒記憶體地址的，自然是不連續的，而連結串列的遍歷方向是由低地址向高地址。
堆的大小受限於計算機系統中有效的虛擬記憶體。
由此可見，堆獲得的空間比較靈活，也比較大。
2.4申請效率的比較：棧由系統自動分配，速度較快。
但程式設計師是無法控制的。
堆是由new分配的記憶體，一般速度比較慢，而且容易產生記憶體碎片,不過用起來最方便.另外，在WINDOWS下，最好的方式是用VirtualAlloc分配記憶體，他不是在堆，也不是在棧是直接在程序的地址空間中保留一快記憶體，雖然用起來最不方便。
但是速度快，也最靈活。
2.5堆和棧中的儲存內容棧：在函式呼叫時，第一個進棧的是主函式中後的下一條指令（函式呼叫語句的下一條可執行語句）的地址，然後是函式的各個引數，在大多數的C編譯器中，引數是由右往左入棧的，然後是函式中的區域性變數。
注意靜態變數是不入棧的。
當本次函式呼叫結束後，區域性變數先出棧，然後是引數，最後棧頂指標指向最開始存的地址，也就是主函式中的下一條指令，程式由該點繼續執行。
堆：一般是在堆的頭部用一個位元組存放堆的大小。
堆中的具體內容有程式設計師安排。
2.6存取效率的比較chars1[]="aaaaaaaaaaaaaaa";char*s2="bbbbbbbbbbbbbbbbb";aaaaaaaaaaa是在執行時刻賦值的；而bbbbbbbbbbb是在編譯時就確定的；但是，在以後的存取中，在棧上的陣列比指標所指向的字串(例如堆)快。
比如：#includevoidmain(){chara=1;charc[]="1234567890";char*p="1234567890";a=c[1];a=p[1];return;}對應的彙編程式碼10:a=c[1];004010678A4DF1movcl,byteptr[ebp-0Fh]0040106A884DFCmovbyteptr[ebp-4],cl11:a=p[1];0040106D8B55ECmovedx,dwordptr[ebp-14h]004010708A4201moval,byteptr[edx1]004010738845FCmovbyteptr[ebp-4],al第一種在讀取時直接就把字串中的元素讀到暫存器cl中，而第二種則要先把指標值讀到edx中，在根據edx讀取字元，顯然慢了。
2.7小結：堆和棧的區別可以用如下的比喻來看出：使用棧就象我們去飯館裡吃飯，只管點菜（發出申請）、付錢、和吃（使用），吃飽了就走，不必理會切菜、洗菜等準備工作和洗碗、刷鍋等掃尾工作，他的好處是快捷，但是自由度小。
使用堆就象是自己動手做喜歡吃的菜餚，比較麻煩，但是比較符合自己的口味，而且自由度大。
windows程序中的記憶體結構在閱讀本文之前，如果你連堆疊是什麼多不知道的話，請先閱讀文章後面的基礎知識。
接觸過程式設計的人都知道，高階語言都能通過變數名來訪問記憶體中的資料。
那麼這些變數在記憶體中是如何存放的呢？程式又是如何使用這些變數的呢？下面就會對此進行深入的討論。
下文中的C語言程式碼如沒有特別宣告，預設都使用VC編譯的release版。
首先，來了解一下C語言的變數是如何在記憶體分部的。
C語言有全域性變數(Global)、本地變數(Local)，靜態變數(Static)、暫存器變數(Regeister)。
每種變數都有不同的分配方式。
先來看下面這段程式碼：#include
其中v1,v2,v3是本地變數，g1,g2,g3是全域性變數，s1,s2,s3是靜態變數。
你可以看到這些變數在記憶體是連續分佈的，但是本地變數和全域性變數分配的記憶體地址差了十萬八千里，而全域性變數和靜態變數分配的記憶體是連續的。
這是因為本地變數和全域性/靜態變數是分配在不同型別的記憶體區域中的結果。
對於一個程序的記憶體空間而言，可以在邏輯上分成3個部份：程式碼區，靜態資料區和動態資料區。
動態資料區一般就是“堆疊”。
“棧(stack)”和“堆(heap)”是兩種不同的動態資料區，棧是一種線性結構，堆是一種鏈式結構。
程序的每個執行緒都有私有的“棧”，所以每個執行緒雖然程式碼一樣，但本地變數的資料都是互不干擾。
一個堆疊可以通過“基地址”和“棧頂”地址來描述。
全域性變數和靜態變數分配在靜態資料區，本地變數分配在動態資料區，即堆疊中。
程式通過堆疊的基地址和偏移量來訪問本地變數。
├———————┤低端記憶體區域│……│├———————┤│動態資料區│├———————┤│……│├———————┤│程式碼區│├———————┤│靜態資料區│├———————┤│……│├———————┤高階記憶體區域堆疊是一個先進後出的資料結構，棧頂地址總是小於等於棧的基地址。
我們可以先了解一下函式呼叫的過程，以便對堆疊在程式中的作用有更深入的瞭解。
不同的語言有不同的函式呼叫規定，這些因素有引數的壓入規則和堆疊的平衡。
windowsAPI的呼叫規則和ANSIC的函式呼叫規則是不一樣的，前者由被調函式調整堆疊，後者由呼叫者調整堆疊。
兩者通過“__stdcall”和“__cdecl”字首區分。
先看下面這段程式碼：#include
該記憶體不能為"read"。
”，“非法操作”嘍！"41"就是"A"的16進位制的ASCII碼了，那明顯就是strcat這句出的問題了。
"lpBuff"的大小隻有8位元組，算進結尾的\0，那strcat最多隻能寫入7個"A"，但程式實際寫入了11個"A"外加1個\0。
再來看看上面那幅圖，多出來的4個位元組正好覆蓋了RET的所在的記憶體空間，導致函式返回到一個錯誤的記憶體地址，執行了錯誤的指令。
如果能精心構造這個字串，使它分成三部分，前一部份僅僅是填充的無意義資料以達到溢位的目的，接著是一個覆蓋RET的資料，緊接著是一段shellcode，那隻要著個RET地址能指向這段shellcode的第一個指令，那函式返回時就能執行shellcode了。
但是軟體的不同版本和不同的執行環境都可能影響這段shellcode在記憶體中的位置，那麼要構造這個RET是十分困難的。
一般都在RET和shellcode之間填充大量的NOP指令，使得exploit有更強的通用性。
├———————┤#include
VC編譯器是通過windows下的“堆(heap)”來實現new關鍵字的記憶體動態分配。
在講“堆”之前，先來了解一下和“堆”有關的幾個API函式：HeapAlloc在堆中申請記憶體空間HeapCreate建立一個新的堆物件HeapDestroy銷燬一個堆物件HeapFree釋放申請的記憶體HeapWalk列舉堆物件的所有記憶體塊GetProcessHeap取得程序的預設堆物件GetProcessHeaps取得程序所有的堆物件LocalAllocGlobalAlloc當程序初始化時，系統會自動為程序建立一個預設堆，這個堆預設所佔記憶體的大小為1M。
堆物件由系統進行管理，它在記憶體中以鏈式結構存在。
通過下面的程式碼可以通過堆動態申請記憶體空間：HANDLEhHeap=GetProcessHeap();char*buff=HeapAlloc(hHeap,0,8);其中hHeap是堆物件的控制代碼，buff是指向申請的記憶體空間的地址。
那這個hHeap究竟是什麼呢？它的值有什麼意義嗎？看看下面這段程式碼吧：#pragmacomment(linker,"/entry:main")//定義程式的入口#include
由函式定義可見，printf的引數個數是可變的，函式內部無法預先知道呼叫者壓入的引數個數，函式只能通過分析第一個引數字串的格式來獲得壓入引數的資訊，由於這裡引數的個數是動態的，所以必須由呼叫者來平衡堆疊，這裡便使用了__cdecl呼叫規則。
BTW，Windows系統的API函式基本上是__stdcall呼叫形式，只有一個API例外，那就是wsprintf，它使用__cdecl呼叫規則，同printf函式一樣，這是由於它的引數個數是可變的緣故。
—————————————————————————/voidmain(){HANDLEhHeap=GetProcessHeap();char*buff=HeapAlloc(hHeap,0,0×10);char*buff2=HeapAlloc(hHeap,0,0×10);HMODULEhMsvcrt=LoadLibrary("msvcrt.dll");printf=(void*)GetProcAddress(hMsvcrt,"printf");printf("0x%08x\n",hHeap);printf("0x%08x\n",buff);printf("0x%08x\n\n",buff2);}執行結果為：0x001300000x001331000x00133118hHeap的值怎麼和那個buff的值那麼接近呢？其實hHeap這個控制代碼就是指向HEAP首部的地址。
在程序的使用者區存著一個叫PEB(程序環境塊)的結構，這個結構中存放著一些有關程序的重要資訊，其中在PEB首地址偏移0x18處存放的ProcessHeap就是程序預設堆的地址，而偏移0x90處存放了指向程序所有堆的地址列表的指標。
windows有很多API都使用程序的預設堆來存放動態資料，如windows2000下的所有ANSI版本的函式都是在預設堆中申請記憶體來轉換ANSI字串到Unicode字串的。
對一個堆的訪問是順序進行的，同一時刻只能有一個執行緒訪問堆中的資料，當多個執行緒同時有訪問要求時，只能排隊等待，這樣便造成程式執行效率下降。
最後來說說記憶體中的資料對齊。
所位資料對齊，是指資料所在的記憶體地址必須是該資料長度的整數倍，DWORD資料的記憶體起始地址能被4除盡，WORD資料的記憶體起始地址能被2除盡，x86CPU能直接訪問對齊的資料，當他試圖訪問一個未對齊的資料時，會在內部進行一系列的調整，這些調整對於程式來說是透明的，但是會降低執行速度，所以編譯器在編譯程式時會盡量保證資料對齊。
同樣一段程式碼，我們來看看用VC、Dev-C和lcc三個不同編譯器編譯出來的程式的執行結果：#include
這是用Dev-C編譯後的執行結果：0x0022ff7c0x0022ff7b0x0022ff74變數在記憶體中的順序：c(4位元組)-中間相隔3位元組-b(佔1位元組)-a(4位元組)。
這是用lcc編譯後的執行結果：0x0012ff6c0x0012ff6b0x0012ff64變數在記憶體中的順序：同上。
三個編譯器都做到了資料對齊，但是後兩個編譯器顯然沒VC“聰明”，讓一個char佔了4位元組，浪費記憶體哦。
基礎知識：堆疊是一種簡單的資料結構，是一種只允許在其一端進行插入或刪除的線性表。
允許插入或刪除操作的一端稱為棧頂，另一端稱為棧底，對堆疊的插入和刪除操作被稱為入棧和出棧。
有一組CPU指令可以實現對程序的記憶體實現堆疊訪問。
其中，POP指令實現出棧操作，PUSH指令實現入棧操作。
CPU的ESP暫存器存放當前執行緒的棧頂指標，EBP暫存器中儲存當前執行緒的棧底指標。
CPU的EIP暫存器存放下一個CPU指令存放的記憶體地址，當CPU執行完當前的指令後，從EIP暫存器中讀取下一條指令的記憶體地址，然後繼續執行。
參考：《Windows下的HEAP溢位及其利用》by:isno《windows核心程式設計》by:JeffreyRichter摘要：討論常見的堆效能問題以及如何防範它們。
（共9頁）前言您是否是動態分配的C/C物件忠實且幸運的使用者？您是否在模組間的往返通訊中頻繁地使用了“自動化”？您的程式是否因堆分配而執行起來很慢？不僅僅您遇到這樣的問題。
幾乎所有專案遲早都會遇到堆問題。
大家都想說，“我的程式碼真正好，只是堆太慢”。
那只是部分正確。
更深入理解堆及其用法、以及會發生什麼問題，是很有用的。
什麼是堆？（如果您已經知道什麼是堆，可以跳到“什麼是常見的堆效能問題？”部分）在程式中，使用堆來動態分配和釋放物件。
在下列情況下，呼叫堆操作：事先不知道程式所需物件的數量和大小。
物件太大而不適合堆疊分配程式。
堆使用了在執行時分配給程式碼和堆疊的記憶體之外的部分記憶體。
下圖給出了堆分配程式的不同層。
GlobalAlloc/GlobalFree：MicrosoftWin32堆呼叫，這些呼叫直接與每個程序的預設堆進行對話。
LocalAlloc/LocalFree：Win32堆呼叫（為了與MicrosoftWindowsNT相容），這些呼叫直接與每個程序的預設堆進行對話。
COM的IMalloc分配程式（或CoTaskMemAlloc/CoTaskMemFree）：函式使用每個程序的預設堆。
自動化程式使用“元件物件模型(COM)”的分配程式，而申請的程式使用每個程序堆。
C/C執行時(CRT)分配程式：提供了malloc()和free()以及new和delete操作符。
如MicrosoftVisualBasic和Java等語言也提供了新的操作符並使用垃圾收集來代替堆。
CRT建立自己的私有堆，駐留在Win32堆的頂部。
WindowsNT中，Win32堆是WindowsNT執行時分配程式周圍的薄層。
所有API轉發它們的請求給NTDLL。
WindowsNT執行時分配程式提供WindowsNT內的核心堆分配程式。
它由具有128個大小從8到1,024位元組的空閒列表的前端分配程式組成。
後端分配程式使用虛擬記憶體來保留和提交頁。
在圖表的底部是“虛擬記憶體分配程式”，作業系統使用它來保留和提交頁。
所有分配程式使用虛擬記憶體進行資料的存取。
分配和釋放塊不就那麼簡單嗎？為何花費這麼長時間？堆實現的注意事項傳統上，作業系統和執行時庫是與堆的實現共存的。
在一個程序的開始，作業系統建立一個預設堆，叫做“程序堆”。
如果沒有其他堆可使用，則塊的分配使用“程序堆”。
語言執行時也能在程序內建立單獨的堆。
（例如，C執行時建立它自己的堆。
）除這些專用的堆外，應用程式或許多已載入的動態連結庫(DLL)之一可以建立和使用單獨的堆。
Win32提供一整套API來建立和使用私有堆。
有關堆函式（英文）的詳盡指導，請參見MSDN。
當應用程式或DLL建立私有堆時，這些堆存在於程序空間，並且在程序內是可訪問的。
從給定堆分配的資料將在同一個堆上釋放。
（不能從一個堆分配而在另一個堆釋放。
）在所有虛擬記憶體系統中，堆駐留在作業系統的“虛擬記憶體管理器”的頂部。
語言執行時堆也駐留在虛擬記憶體頂部。
某些情況下，這些堆是作業系統堆中的層，而語言執行時堆則通過大塊的分配來執行自己的記憶體管理。
不使用作業系統堆，而使用虛擬記憶體函式更利於堆的分配和塊的使用。
典型的堆實現由前、後端分配程式組成。
前端分配程式維持固定大小塊的空閒列表。
對於一次分配呼叫，堆嘗試從前端列表找到一個自由塊。
如果失敗，堆被迫從後端（保留和提交虛擬記憶體）分配一個大塊來滿足請求。
通用的實現有每塊分配的開銷，這將耗費執行週期，也減少了可使用的儲存空間。
KnowledgeBase文章Q10758，“用calloc()和malloc()管理記憶體”（搜尋文章編號）,包含了有關這些主題的更多背景知識。
另外，有關堆實現和設計的詳細討論也可在下列著作中找到：“DynamicStorageAllocation:ASurveyandCriticalReview”，作者PaulR.Wilson、MarkS.Johnstone、MichaelNeely和DavidBoles；“InternationalWorkshoponMemoryManagement”,作者Kinross,Scotland,UK,1995年9月(http://www.cs.utexas.edu/users/oops/papers.html)（英文）。
WindowsNT的實現（WindowsNT版本4.0和更新版本）使用了127個大小從8到1,024位元組的8位元組對齊塊空閒列表和一個“大塊”列表。
“大塊”列表（空閒列表[0]）儲存大於1,024位元組的塊。
空閒列表容納了用雙向連結串列連結在一起的物件。
預設情況下，“程序堆”執行收集操作。
（收集是將相鄰空閒塊合併成一個大塊的操作。
）收集耗費了額外的週期，但減少了堆塊的內部碎片。
單一全域性鎖保護堆，防止多執行緒式的使用。
（請參見“ServerPerformanceandScalabilityKillers”中的第一個注意事項,GeorgeReilly所著，在“MSDNOnlineWebWorkshop”上（站點：http://msdn.microsoft.com/workshop/server/iis/tencom.asp（英文）。
）單一全域性鎖本質上是用來保護堆資料結構，防止跨多執行緒的隨機存取。
若堆操作太頻繁，單一全域性鎖會對效能有不利的影響。
什麼是常見的堆效能問題？以下是您使用堆時會遇到的最常見問題：分配操作造成的速度減慢。
光分配就耗費很長時間。
最可能導致執行速度減慢原因是空閒列表沒有塊，所以執行時分配程式程式碼會耗費週期尋找較大的空閒塊，或從後端分配程式分配新塊。
釋放操作造成的速度減慢。
釋放操作耗費較多週期，主要是啟用了收集操作。
收集期間，每個釋放操作“查詢”它的相鄰塊，取出它們並構造成較大塊，然後再把此較大塊插入空閒列表。
在查詢期間，記憶體可能會隨機碰到，從而導致快取記憶體不能命中，效能降低。
堆競爭造成的速度減慢。
當兩個或多個執行緒同時訪問資料，而且一個執行緒繼續進行之前必須等待另一個執行緒完成時就發生競爭。
競爭總是導致麻煩；這也是目前多處理器系統遇到的最大問題。
當大量使用記憶體塊的應用程式或DLL以多執行緒方式執行（或執行於多處理器系統上）時將導致速度減慢。
單一鎖定的使用—常用的解決方案—意味著使用堆的所有操作是序列化的。
當等待鎖定時序列化會引起執行緒切換上下文。
可以想象交叉路口閃爍的紅燈處走走停停導致的速度減慢。
競爭通常會導致執行緒和程序的上下文切換。
上下文切換的開銷是很大的，但開銷更大的是資料從處理器快取記憶體中丟失，以及後來執行緒復活時的資料重建。
堆破壞造成的速度減慢。
造成堆破壞的原因是應用程式對堆塊的不正確使用。
通常情形包括釋放已釋放的堆塊或使用已釋放的堆塊，以及塊的越界重寫等明顯問題。
（破壞不在本文討論範圍之內。
有關記憶體重寫和洩漏等其他細節，請參見MicrosoftVisualC(R)除錯文件。
）頻繁的分配和重分配造成的速度減慢。
這是使用指令碼語言時非常普遍的現象。
如字串被反覆分配，隨重分配增長和釋放。
不要這樣做，如果可能，儘量分配大字串和使用緩衝區。
另一種方法就是儘量少用連線操作。
競爭是在分配和釋放操作中導致速度減慢的問題。
理想情況下，希望使用沒有競爭和快速分配/釋放的堆。
可惜，現在還沒有這樣的通用堆，也許將來會有。
在所有的伺服器系統中（如IIS、MSProxy、DatabaseStacks、網路伺服器、Exchange和其他）,堆鎖定實在是個大瓶頸。
處理器數越多，競爭就越會惡化。
儘量減少堆的使用現在您明白使用堆時存在的問題了，難道您不想擁有能解決這些問題的超級魔棒嗎？我可希望有。
但沒有魔法能使堆執行加快—因此不要期望在產品出貨之前的最後一星期能夠大為改觀。
如果提前規劃堆策略，情況將會大大好轉。
調整使用堆的方法，減少對堆的操作是提高效能的良方。
如何減少使用堆操作？通過利用資料結構內的位置可減少堆操作的次數。
請考慮下列例項：structObjectA{//objectA的資料}structObjectB{//objectB的資料}//同時使用objectA和objectB////使用指標//structObjectB{structObjectA*pObjA;//objectB的資料}////使用嵌入//structObjectB{structObjectApObjA;//objectB的資料}////集合–在另一物件內使用objectA和objectB//structObjectX{structObjectAobjA;structObjectBobjB;}避免使用指標關聯兩個資料結構。
如果使用指標關聯兩個資料結構，前面例項中的物件A和B將被分別分配和釋放。
這會增加額外開銷—我們要避免這種做法。
把帶指標的子物件嵌入父物件。
當物件中有指標時，則意味著物件中有動態元素（百分之八十）和沒有引用的新位置。
嵌入增加了位置從而減少了進一步分配/釋放的需求。
這將提高應用程式的效能。
合併小物件形成大物件（聚合）。
聚合減少分配和釋放的塊的數量。
如果有幾個開發者，各自開發設計的不同部分，則最終會有許多小物件需要合併。
整合的挑戰就是要找到正確的聚合邊界。
內聯緩衝區能夠滿足百分之八十的需要（aka80-20規則）。
個別情況下，需要記憶體緩衝區來儲存字串/二進位制資料，但事先不知道總位元組數。
估計並內聯一個大小能滿足百分之八十需要的緩衝區。
對剩餘的百分之二十，可以分配一個新的緩衝區和指向這個緩衝區的指標。
這樣，就減少分配和釋放呼叫並增加資料的位置空間，從根本上提高程式碼的效能。
在塊中分配物件（塊化）。
塊化是以組的方式一次分配多個物件的方法。
如果對列表的項連續跟蹤，例如對一個{名稱，值}對的列表，有兩種選擇：選擇一是為每一個“名稱-值”對分配一個節點；選擇二是分配一個能容納（如五個）“名稱-值”對的結構。
例如，一般情況下，如果儲存四對，就可減少節點的數量，如果需要額外的空間數量，則使用附加的連結串列指標。
塊化是友好的處理器快取記憶體，特別是對於L1-快取記憶體，因為它提供了增加的位置—不用說對於塊分配，很多資料塊會在同一個虛擬頁中。
正確使用_amblksiz。
C執行時(CRT)有它的自定義前端分配程式，該分配程式從後端（Win32堆）分配大小為_amblksiz的塊。
將_amblksiz設定為較高的值能潛在地減少對後端的呼叫次數。
這隻對廣泛使用CRT的程式適用。
使用上述技術將獲得的好處會因物件型別、大小及工作量而有所不同。
但總能在效能和可升縮性方面有所收穫。
另一方面，程式碼會有點特殊，但如果經過深思熟慮，程式碼還是很容易管理的。
其他提高效能的技術下面是一些提高速度的技術：使用WindowsNT5堆由於幾個同事的努力和辛勤工作，1998年初MicrosoftWindows(R)2000中有了幾個重大改進：改進了堆程式碼內的鎖定。
堆程式碼對每堆一個鎖。
全域性鎖保護堆資料結構，防止多執行緒式的使用。
但不幸的是，在高通訊量的情況下，堆仍受困於全域性鎖，導致高競爭和低效能。
Windows2000中，鎖內程式碼的臨界區將競爭的可能性減到最小,從而提高了可伸縮性。
使用“Lookaside”列表。
堆資料結構對塊的所有空閒項使用了大小在8到1,024位元組（以8-位元組遞增）的快速快取記憶體。
快速快取記憶體最初保護在全域性鎖內。
現在，使用lookaside列表來訪問這些快速快取記憶體空閒列表。
這些列表不要求鎖定，而是使用64位的互鎖操作，因此提高了效能。
內部資料結構演算法也得到改進。
這些改進避免了對分配快取記憶體的需求，但不排除其他的優化。
使用WindowsNT5堆評估您的程式碼；它對小於1,024位元組(1KB)的塊（來自前端分配程式的塊）是最佳的。
GlobalAlloc()和LocalAlloc()建立在同一堆上，是存取每個程序堆的通用機制。
如果希望獲得高的區域性效能，則使用Heap(R)API來存取每個程序堆，或為分配操作建立自己的堆。
如果需要對大塊操作，也可以直接使用VirtualAlloc()/VirtualFree()操作。
上述改進已在Windows2000beta2和WindowsNT4.0SP4中使用。
改進後，堆鎖的競爭率顯著降低。
這使所有Win32堆的直接使用者受益。
CRT堆建立於Win32堆的頂部，但它使用自己的小塊堆，因而不能從WindowsNT改進中受益。
（VisualC版本6.0也有改進的堆分配程式。
）使用分配快取記憶體分配快取記憶體允許快取記憶體分配的塊，以便將來重用。
這能夠減少對程序堆（或全域性堆）的分配/釋放呼叫的次數，也允許最大限度的重用曾經分配的塊。
另外，分配快取記憶體允許收集統計資訊,以便較好地理解物件在較高層次上的使用。
典型地，自定義堆分配程式在程序堆的頂部實現。
自定義堆分配程式與系統堆的行為很相似。
主要的差別是它在程序堆的頂部為分配的物件提供快取記憶體。
快取記憶體設計成一套固定大小（如32位元組、64位元組、128位元組等）。
這一個很好的策略，但這種自定義堆分配程式丟失與分配和釋放的物件相關的“語義資訊”。
與自定義堆分配程式相反，“分配快取記憶體”作為每類分配快取記憶體來實現。
除能夠提供自定義堆分配程式的所有好處之外，它們還能夠保留大量語義資訊。
每個分配快取記憶體處理程式與一個目標二進位制物件關聯。
它能夠使用一套引數進行初始化，這些參數列示併發級別、物件大小和保持在空閒列表中的元素的數量等。
分配快取記憶體處理程式物件維持自己的私有空閒實體池（不超過指定的閥值）並使用私有保護鎖。
合在一起，分配快取記憶體和私有鎖減少了與主系統堆的通訊量，因而提供了增加的併發、最大限度的重用和較高的可伸縮性。
需要使用清理程式來定期檢查所有分配快取記憶體處理程式的活動情況並回收未用的資源。
如果發現沒有活動，將釋放分配物件的池，從而提高效能。
可以稽核每個分配/釋放活動。
第一級資訊包括物件、分配和釋放呼叫的總數。
通過檢視它們的統計資訊可以得出各個物件之間的語義關係。
利用以上介紹的許多技術之一，這種關係可以用來減少記憶體分配。
分配快取記憶體也起到了除錯助手的作用，幫助您跟蹤沒有完全清除的物件數量。
通過檢視動態堆疊返回蹤跡和除沒有清除的物件之外的簽名，甚至能夠找到確切的失敗的呼叫者。
MP堆MP堆是對多處理器友好的分散式分配的程式包，在Win32SDK（WindowsNT4.0和更新版本）中可以得到。
最初由JVert實現，此處堆抽象建立在Win32堆程式包的頂部。
MP堆建立多個Win32堆，並試圖將分配呼叫分佈到不同堆，以減少在所有單一鎖上的競爭。
本程式包是好的步驟—一種改進的MP-友好的自定義堆分配程式。
但是，它不提供語義資訊和缺乏統計功能。
通常將MP堆作為SDK庫來使用。
如果使用這個SDK建立可重用元件，您將大大受益。
但是，如果在每個DLL中建立這個SDK庫，將增加工作設定。
重新思考演算法和資料結構要在多處理器機器上伸縮，則演算法、實現、資料結構和硬體必須動態伸縮。
請看最經常分配和釋放的資料結構。
試問，“我能用不同的資料結構完成此工作嗎？”例如，如果在應用程式初始化時載入了只讀項的列表，這個列表不必是線性連結的列表。
如果是動態分配的陣列就非常好。
動態分配的陣列將減少記憶體中的堆塊和碎片，從而增強效能。
減少需要的小物件的數量減少堆分配程式的負載。
例如，我們在伺服器的關鍵處理路徑上使用五個不同的物件，每個物件單獨分配和釋放。
一起快取記憶體這些物件，把堆呼叫從五個減少到一個，顯著減少了堆的負載，特別當每秒鐘處理1,000個以上的請求時。
如果大量使用“Automation”結構，請考慮從主線程式碼中刪除“AutomationBSTR”，或至少避免重複的BSTR操作。
（BSTR連線導致過多的重分配和分配/釋放操作。
）摘要對所有平臺往往都存在堆實現，因此有巨大的開銷。
每個單獨程式碼都有特定的要求，但設計能採用本文討論的基本理論來減少堆之間的相互作用。
評價您的程式碼中堆的使用。
改進您的程式碼，以使用較少的堆呼叫：分析關鍵路徑和固定資料結構。
在實現自定義的包裝程式之前使用量化堆呼叫成本的方法。
如果對效能不滿意，請要求OS組改進堆。
更多這類請求意味著對改進堆的更多關注。
要求C執行時組針對OS所提供的堆製作小巧的分配包裝程式。
隨著OS堆的改進，C執行時堆呼叫的成本將減小。
作業系統（WindowsNT家族）正在不斷改進堆。
請隨時關注和利用這些改進。
MuraliKrishnan是InternetInformationServer(IIS)組的首席軟體設計工程師。
從1.0版本開始他就設計IIS，併成功發行了1.0版本到4.0版本。
Murali組織並領導IIS效能組三年(1995-1998),從一開始就影響IIS效能。
他擁有威斯康星州Madison大學的M.S.和印度Anna大學的B.S.。
工作之外，他喜歡閱讀、打排球和家庭烹飪。
http://community.csdn.net/Expert/FAQ/FAQ_Index.asp?id=172835我在學習物件的生存方式的時候見到一種是在堆疊(stack)之中，如下CObjectobject;還有一種是在堆(heap)中如下CObject*pobject=newCObject();請問（1）這兩種方式有什麼區別？（2）堆疊與堆有什麼區別？？aboutstack,systemwillallocatememorytotheinstanceofobjectautomatically,andtotheheap,youmustallocatememorytotheinstanceofobjectwithnewormallocmanually.whenfunctionends,systemwillautomaticallyfreethememoryareaofstack,buttotheheap,youmustfreethememoryareamanuallywithfreeordelete,elseitwillresultinmemoryleak.3)棧記憶體分配運算內建於處理器的指令集中，效率很高，但是分配的記憶體容量有限。
4）堆上分配的記憶體可以有我們自己決定，使用非常靈活。
二、例子程式這是一個前輩寫的，非常詳細//main.cppinta=0;全域性初始化區char*p1;全域性未初始化區main(){intb;棧chars[]="abc";棧char*p2;棧char*p3="123456";123456\0在常量區，p3在棧上。
staticintc=0；全域性（靜態）初始化區p1=(char*)malloc(10);p2=(char*)malloc(20);分配得來得10和20位元組的區域就在堆區。
strcpy(p1,"123456");123456\0放在常量區，編譯器可能會將它與p3所指向的"123456"優化成一個地方。
}二、堆和棧的理論知識2.1申請方式stack:由系統自動分配。
例如，宣告在函式中一個區域性變數intb;系統自動在棧中為b開闢空間heap:需要程式設計師自己申請，並指明大小，在c中malloc函式如p1=(char*)malloc(10);在C中用new運算子如p2=(char*)malloc(10);但是注意p1、p2本身是在棧中的。
2.2申請後系統的響應棧：只要棧的剩餘空間大於所申請空間，系統將為程式提供記憶體，否則將報異常提示棧溢位。
堆：首先應該知道作業系統有一個記錄空閒記憶體地址的連結串列，當系統收到程式的申請時，會遍歷該連結串列，尋找第一個空間大於所申請空間的堆結點，然後將該結點從空閒結點連結串列中刪除，並將該結點的空間分配給程式，另外，對於大多數系統，會在這塊記憶體空間中的首地址處記錄本次分配的大小，這樣，程式碼中的delete語句才能正確的釋放本記憶體空間。
另外，由於找到的堆結點的大小不一定正好等於申請的大小，系統會自動的將多餘的那部分重新放入空閒連結串列中。
2.3申請大小的限制棧：在Windows下,棧是向低地址擴充套件的資料結構，是一塊連續的記憶體的區域。
這句話的意思是棧頂的地址和棧的最大容量是系統預先規定好的，在WINDOWS下，棧的大小是2M（也有的說是1M，總之是一個編譯時就確定的常數），如果申請的空間超過棧的剩餘空間時，將提示overflow。
因此，能從棧獲得的空間較小。
堆：堆是向高地址擴充套件的資料結構，是不連續的記憶體區域。
這是由於系統是用連結串列來儲存的空閒記憶體地址的，自然是不連續的，而連結串列的遍歷方向是由低地址向高地址。
堆的大小受限於計算機系統中有效的虛擬記憶體。
由此可見，堆獲得的空間比較靈活，也比較大。
2.4申請效率的比較：棧由系統自動分配，速度較快。
但程式設計師是無法控制的。
堆是由new分配的記憶體，一般速度比較慢，而且容易產生記憶體碎片,不過用起來最方便.另外，在WINDOWS下，最好的方式是用VirtualAlloc分配記憶體，他不是在堆，也不是在棧是直接在程序的地址空間中保留一快記憶體，雖然用起來最不方便。
但是速度快，也最靈活。
2.5堆和棧中的儲存內容棧：在函式呼叫時，第一個進棧的是主函式中後的下一條指令（函式呼叫語句的下一條可執行語句）的地址，然後是函式的各個引數，在大多數的C編譯器中，引數是由右往左入棧的，然後是函式中的區域性變數。
注意靜態變數是不入棧的。
當本次函式呼叫結束後，區域性變數先出棧，然後是引數，最後棧頂指標指向最開始存的地址，也就是主函式中的下一條指令，程式由該點繼續執行。
堆：一般是在堆的頭部用一個位元組存放堆的大小。
堆中的具體內容有程式設計師安排。
2.6存取效率的比較chars1[]="aaaaaaaaaaaaaaa";char*s2="bbbbbbbbbbbbbbbbb";aaaaaaaaaaa是在執行時刻賦值的；而bbbbbbbbbbb是在編譯時就確定的；但是，在以後的存取中，在棧上的陣列比指標所指向的字串(例如堆)快。
比如：#includevoidmain(){chara=1;charc[]="1234567890";char*p="1234567890";a=c[1];a=p[1];return;}對應的彙編程式碼10:a=c[1];004010678A4DF1movcl,byteptr[ebp-0Fh]0040106A884DFCmovbyteptr[ebp-4],cl11:a=p[1];0040106D8B55ECmovedx,dwordptr[ebp-14h]004010708A4201moval,byteptr[edx1]004010738845FCmovbyteptr[ebp-4],al第一種在讀取時直接就把字串中的元素讀到暫存器cl中，而第二種則要先把指標值讀到edx中，在根據edx讀取字元，顯然慢了。
2.7小結：堆和棧的區別可以用如下的比喻來看出：使用棧就象我們去飯館裡吃飯，只管點菜（發出申請）、付錢、和吃（使用），吃飽了就走，不必理會切菜、洗菜等準備工作和洗碗、刷鍋等掃尾工作，他的好處是快捷，但是自由度小。
使用堆就象是自己動手做喜歡吃的菜餚，比較麻煩，但是比較符合自己的口味，而且自由度大。
windows程序中的記憶體結構在閱讀本文之前，如果你連堆疊是什麼多不知道的話，請先閱讀文章後面的基礎知識。
接觸過程式設計的人都知道，高階語言都能通過變數名來訪問記憶體中的資料。
那麼這些變數在記憶體中是如何存放的呢？程式又是如何使用這些變數的呢？下面就會對此進行深入的討論。
下文中的C語言程式碼如沒有特別宣告，預設都使用VC編譯的release版。
首先，來了解一下C語言的變數是如何在記憶體分部的。
C語言有全域性變數(Global)、本地變數(Local)，靜態變數(Static)、暫存器變數(Regeister)。
每種變數都有不同的分配方式。
先來看下面這段程式碼：#include
其中v1,v2,v3是本地變數，g1,g2,g3是全域性變數，s1,s2,s3是靜態變數。
你可以看到這些變數在記憶體是連續分佈的，但是本地變數和全域性變數分配的記憶體地址差了十萬八千里，而全域性變數和靜態變數分配的記憶體是連續的。
這是因為本地變數和全域性/靜態變數是分配在不同型別的記憶體區域中的結果。
對於一個程序的記憶體空間而言，可以在邏輯上分成3個部份：程式碼區，靜態資料區和動態資料區。
動態資料區一般就是“堆疊”。
“棧(stack)”和“堆(heap)”是兩種不同的動態資料區，棧是一種線性結構，堆是一種鏈式結構。
程序的每個執行緒都有私有的“棧”，所以每個執行緒雖然程式碼一樣，但本地變數的資料都是互不干擾。
一個堆疊可以通過“基地址”和“棧頂”地址來描述。
全域性變數和靜態變數分配在靜態資料區，本地變數分配在動態資料區，即堆疊中。
程式通過堆疊的基地址和偏移量來訪問本地變數。
├———————┤低端記憶體區域│……│├———————┤│動態資料區│├———————┤│……│├———————┤│程式碼區│├———————┤│靜態資料區│├———————┤│……│├———————┤高階記憶體區域堆疊是一個先進後出的資料結構，棧頂地址總是小於等於棧的基地址。
我們可以先了解一下函式呼叫的過程，以便對堆疊在程式中的作用有更深入的瞭解。
不同的語言有不同的函式呼叫規定，這些因素有引數的壓入規則和堆疊的平衡。
windowsAPI的呼叫規則和ANSIC的函式呼叫規則是不一樣的，前者由被調函式調整堆疊，後者由呼叫者調整堆疊。
兩者通過“__stdcall”和“__cdecl”字首區分。
先看下面這段程式碼：#include
該記憶體不能為"read"。
”，“非法操作”嘍！"41"就是"A"的16進位制的ASCII碼了，那明顯就是strcat這句出的問題了。
"lpBuff"的大小隻有8位元組，算進結尾的\0，那strcat最多隻能寫入7個"A"，但程式實際寫入了11個"A"外加1個\0。
再來看看上面那幅圖，多出來的4個位元組正好覆蓋了RET的所在的記憶體空間，導致函式返回到一個錯誤的記憶體地址，執行了錯誤的指令。
如果能精心構造這個字串，使它分成三部分，前一部份僅僅是填充的無意義資料以達到溢位的目的，接著是一個覆蓋RET的資料，緊接著是一段shellcode，那隻要著個RET地址能指向這段shellcode的第一個指令，那函式返回時就能執行shellcode了。
但是軟體的不同版本和不同的執行環境都可能影響這段shellcode在記憶體中的位置，那麼要構造這個RET是十分困難的。
一般都在RET和shellcode之間填充大量的NOP指令，使得exploit有更強的通用性。
├———————┤#include
VC編譯器是通過windows下的“堆(heap)”來實現new關鍵字的記憶體動態分配。
在講“堆”之前，先來了解一下和“堆”有關的幾個API函式：HeapAlloc在堆中申請記憶體空間HeapCreate建立一個新的堆物件HeapDestroy銷燬一個堆物件HeapFree釋放申請的記憶體HeapWalk列舉堆物件的所有記憶體塊GetProcessHeap取得程序的預設堆物件GetProcessHeaps取得程序所有的堆物件LocalAllocGlobalAlloc當程序初始化時，系統會自動為程序建立一個預設堆，這個堆預設所佔記憶體的大小為1M。
堆物件由系統進行管理，它在記憶體中以鏈式結構存在。
通過下面的程式碼可以通過堆動態申請記憶體空間：HANDLEhHeap=GetProcessHeap();char*buff=HeapAlloc(hHeap,0,8);其中hHeap是堆物件的控制代碼，buff是指向申請的記憶體空間的地址。
那這個hHeap究竟是什麼呢？它的值有什麼意義嗎？看看下面這段程式碼吧：#pragmacomment(linker,"/entry:main")//定義程式的入口#include
由函式定義可見，printf的引數個數是可變的，函式內部無法預先知道呼叫者壓入的引數個數，函式只能通過分析第一個引數字串的格式來獲得壓入引數的資訊，由於這裡引數的個數是動態的，所以必須由呼叫者來平衡堆疊，這裡便使用了__cdecl呼叫規則。
BTW，Windows系統的API函式基本上是__stdcall呼叫形式，只有一個API例外，那就是wsprintf，它使用__cdecl呼叫規則，同printf函式一樣，這是由於它的引數個數是可變的緣故。
—————————————————————————/voidmain(){HANDLEhHeap=GetProcessHeap();char*buff=HeapAlloc(hHeap,0,0×10);char*buff2=HeapAlloc(hHeap,0,0×10);HMODULEhMsvcrt=LoadLibrary("msvcrt.dll");printf=(void*)GetProcAddress(hMsvcrt,"printf");printf("0x%08x\n",hHeap);printf("0x%08x\n",buff);printf("0x%08x\n\n",buff2);}執行結果為：0x001300000x001331000x00133118hHeap的值怎麼和那個buff的值那麼接近呢？其實hHeap這個控制代碼就是指向HEAP首部的地址。
在程序的使用者區存著一個叫PEB(程序環境塊)的結構，這個結構中存放著一些有關程序的重要資訊，其中在PEB首地址偏移0x18處存放的ProcessHeap就是程序預設堆的地址，而偏移0x90處存放了指向程序所有堆的地址列表的指標。
windows有很多API都使用程序的預設堆來存放動態資料，如windows2000下的所有ANSI版本的函式都是在預設堆中申請記憶體來轉換ANSI字串到Unicode字串的。
對一個堆的訪問是順序進行的，同一時刻只能有一個執行緒訪問堆中的資料，當多個執行緒同時有訪問要求時，只能排隊等待，這樣便造成程式執行效率下降。
最後來說說記憶體中的資料對齊。
所位資料對齊，是指資料所在的記憶體地址必須是該資料長度的整數倍，DWORD資料的記憶體起始地址能被4除盡，WORD資料的記憶體起始地址能被2除盡，x86CPU能直接訪問對齊的資料，當他試圖訪問一個未對齊的資料時，會在內部進行一系列的調整，這些調整對於程式來說是透明的，但是會降低執行速度，所以編譯器在編譯程式時會盡量保證資料對齊。
同樣一段程式碼，我們來看看用VC、Dev-C和lcc三個不同編譯器編譯出來的程式的執行結果：#include
這是用Dev-C編譯後的執行結果：0x0022ff7c0x0022ff7b0x0022ff74變數在記憶體中的順序：c(4位元組)-中間相隔3位元組-b(佔1位元組)-a(4位元組)。
這是用lcc編譯後的執行結果：0x0012ff6c0x0012ff6b0x0012ff64變數在記憶體中的順序：同上。
三個編譯器都做到了資料對齊，但是後兩個編譯器顯然沒VC“聰明”，讓一個char佔了4位元組，浪費記憶體哦。
基礎知識：堆疊是一種簡單的資料結構，是一種只允許在其一端進行插入或刪除的線性表。
允許插入或刪除操作的一端稱為棧頂，另一端稱為棧底，對堆疊的插入和刪除操作被稱為入棧和出棧。
有一組CPU指令可以實現對程序的記憶體實現堆疊訪問。
其中，POP指令實現出棧操作，PUSH指令實現入棧操作。
CPU的ESP暫存器存放當前執行緒的棧頂指標，EBP暫存器中儲存當前執行緒的棧底指標。
CPU的EIP暫存器存放下一個CPU指令存放的記憶體地址，當CPU執行完當前的指令後，從EIP暫存器中讀取下一條指令的記憶體地址，然後繼續執行。
參考：《Windows下的HEAP溢位及其利用》by:isno《windows核心程式設計》by:JeffreyRichter摘要：討論常見的堆效能問題以及如何防範它們。
（共9頁）前言您是否是動態分配的C/C物件忠實且幸運的使用者？您是否在模組間的往返通訊中頻繁地使用了“自動化”？您的程式是否因堆分配而執行起來很慢？不僅僅您遇到這樣的問題。
幾乎所有專案遲早都會遇到堆問題。
大家都想說，“我的程式碼真正好，只是堆太慢”。
那只是部分正確。
更深入理解堆及其用法、以及會發生什麼問題，是很有用的。
什麼是堆？（如果您已經知道什麼是堆，可以跳到“什麼是常見的堆效能問題？”部分）在程式中，使用堆來動態分配和釋放物件。
在下列情況下，呼叫堆操作：事先不知道程式所需物件的數量和大小。
物件太大而不適合堆疊分配程式。
堆使用了在執行時分配給程式碼和堆疊的記憶體之外的部分記憶體。
下圖給出了堆分配程式的不同層。
GlobalAlloc/GlobalFree：MicrosoftWin32堆呼叫，這些呼叫直接與每個程序的預設堆進行對話。
LocalAlloc/LocalFree：Win32堆呼叫（為了與MicrosoftWindowsNT相容），這些呼叫直接與每個程序的預設堆進行對話。
COM的IMalloc分配程式（或CoTaskMemAlloc/CoTaskMemFree）：函式使用每個程序的預設堆。
自動化程式使用“元件物件模型(COM)”的分配程式，而申請的程式使用每個程序堆。
C/C執行時(CRT)分配程式：提供了malloc()和free()以及new和delete操作符。
如MicrosoftVisualBasic和Java等語言也提供了新的操作符並使用垃圾收集來代替堆。
CRT建立自己的私有堆，駐留在Win32堆的頂部。
WindowsNT中，Win32堆是WindowsNT執行時分配程式周圍的薄層。
所有API轉發它們的請求給NTDLL。
WindowsNT執行時分配程式提供WindowsNT內的核心堆分配程式。
它由具有128個大小從8到1,024位元組的空閒列表的前端分配程式組成。
後端分配程式使用虛擬記憶體來保留和提交頁。
在圖表的底部是“虛擬記憶體分配程式”，作業系統使用它來保留和提交頁。
所有分配程式使用虛擬記憶體進行資料的存取。
分配和釋放塊不就那麼簡單嗎？為何花費這麼長時間？堆實現的注意事項傳統上，作業系統和執行時庫是與堆的實現共存的。
在一個程序的開始，作業系統建立一個預設堆，叫做“程序堆”。
如果沒有其他堆可使用，則塊的分配使用“程序堆”。
語言執行時也能在程序內建立單獨的堆。
（例如，C執行時建立它自己的堆。
）除這些專用的堆外，應用程式或許多已載入的動態連結庫(DLL)之一可以建立和使用單獨的堆。
Win32提供一整套API來建立和使用私有堆。
有關堆函式（英文）的詳盡指導，請參見MSDN。
當應用程式或DLL建立私有堆時，這些堆存在於程序空間，並且在程序內是可訪問的。
從給定堆分配的資料將在同一個堆上釋放。
（不能從一個堆分配而在另一個堆釋放。
）在所有虛擬記憶體系統中，堆駐留在作業系統的“虛擬記憶體管理器”的頂部。
語言執行時堆也駐留在虛擬記憶體頂部。
某些情況下，這些堆是作業系統堆中的層，而語言執行時堆則通過大塊的分配來執行自己的記憶體管理。
不使用作業系統堆，而使用虛擬記憶體函式更利於堆的分配和塊的使用。
典型的堆實現由前、後端分配程式組成。
前端分配程式維持固定大小塊的空閒列表。
對於一次分配呼叫，堆嘗試從前端列表找到一個自由塊。
如果失敗，堆被迫從後端（保留和提交虛擬記憶體）分配一個大塊來滿足請求。
通用的實現有每塊分配的開銷，這將耗費執行週期，也減少了可使用的儲存空間。
KnowledgeBase文章Q10758，“用calloc()和malloc()管理記憶體”（搜尋文章編號）,包含了有關這些主題的更多背景知識。
另外，有關堆實現和設計的詳細討論也可在下列著作中找到：“DynamicStorageAllocation:ASurveyandCriticalReview”，作者PaulR.Wilson、MarkS.Johnstone、MichaelNeely和DavidBoles；“InternationalWorkshoponMemoryManagement”,作者Kinross,Scotland,UK,1995年9月(http://www.cs.utexas.edu/users/oops/papers.html)（英文）。
WindowsNT的實現（WindowsNT版本4.0和更新版本）使用了127個大小從8到1,024位元組的8位元組對齊塊空閒列表和一個“大塊”列表。
“大塊”列表（空閒列表[0]）儲存大於1,024位元組的塊。
空閒列表容納了用雙向連結串列連結在一起的物件。
預設情況下，“程序堆”執行收集操作。
（收集是將相鄰空閒塊合併成一個大塊的操作。
）收集耗費了額外的週期，但減少了堆塊的內部碎片。
單一全域性鎖保護堆，防止多執行緒式的使用。
（請參見“ServerPerformanceandScalabilityKillers”中的第一個注意事項,GeorgeReilly所著，在“MSDNOnlineWebWorkshop”上（站點：http://msdn.microsoft.com/workshop/server/iis/tencom.asp（英文）。
）單一全域性鎖本質上是用來保護堆資料結構，防止跨多執行緒的隨機存取。
若堆操作太頻繁，單一全域性鎖會對效能有不利的影響。
什麼是常見的堆效能問題？以下是您使用堆時會遇到的最常見問題：分配操作造成的速度減慢。
光分配就耗費很長時間。
最可能導致執行速度減慢原因是空閒列表沒有塊，所以執行時分配程式程式碼會耗費週期尋找較大的空閒塊，或從後端分配程式分配新塊。
釋放操作造成的速度減慢。
釋放操作耗費較多週期，主要是啟用了收集操作。
收集期間，每個釋放操作“查詢”它的相鄰塊，取出它們並構造成較大塊，然後再把此較大塊插入空閒列表。
在查詢期間，記憶體可能會隨機碰到，從而導致快取記憶體不能命中，效能降低。
堆競爭造成的速度減慢。
當兩個或多個執行緒同時訪問資料，而且一個執行緒繼續進行之前必須等待另一個執行緒完成時就發生競爭。
競爭總是導致麻煩；這也是目前多處理器系統遇到的最大問題。
當大量使用記憶體塊的應用程式或DLL以多執行緒方式執行（或執行於多處理器系統上）時將導致速度減慢。
單一鎖定的使用—常用的解決方案—意味著使用堆的所有操作是序列化的。
當等待鎖定時序列化會引起執行緒切換上下文。
可以想象交叉路口閃爍的紅燈處走走停停導致的速度減慢。
競爭通常會導致執行緒和程序的上下文切換。
上下文切換的開銷是很大的，但開銷更大的是資料從處理器快取記憶體中丟失，以及後來執行緒復活時的資料重建。
堆破壞造成的速度減慢。
造成堆破壞的原因是應用程式對堆塊的不正確使用。
通常情形包括釋放已釋放的堆塊或使用已釋放的堆塊，以及塊的越界重寫等明顯問題。
（破壞不在本文討論範圍之內。
有關記憶體重寫和洩漏等其他細節，請參見MicrosoftVisualC(R)除錯文件。
）頻繁的分配和重分配造成的速度減慢。
這是使用指令碼語言時非常普遍的現象。
如字串被反覆分配，隨重分配增長和釋放。
不要這樣做，如果可能，儘量分配大字串和使用緩衝區。
另一種方法就是儘量少用連線操作。
競爭是在分配和釋放操作中導致速度減慢的問題。
理想情況下，希望使用沒有競爭和快速分配/釋放的堆。
可惜，現在還沒有這樣的通用堆，也許將來會有。
在所有的伺服器系統中（如IIS、MSProxy、DatabaseStacks、網路伺服器、Exchange和其他）,堆鎖定實在是個大瓶頸。
處理器數越多，競爭就越會惡化。
儘量減少堆的使用現在您明白使用堆時存在的問題了，難道您不想擁有能解決這些問題的超級魔棒嗎？我可希望有。
但沒有魔法能使堆執行加快—因此不要期望在產品出貨之前的最後一星期能夠大為改觀。
如果提前規劃堆策略，情況將會大大好轉。
調整使用堆的方法，減少對堆的操作是提高效能的良方。
如何減少使用堆操作？通過利用資料結構內的位置可減少堆操作的次數。
請考慮下列例項：structObjectA{//objectA的資料}structObjectB{//objectB的資料}//同時使用objectA和objectB////使用指標//structObjectB{structObjectA*pObjA;//objectB的資料}////使用嵌入//structObjectB{structObjectApObjA;//objectB的資料}////集合–在另一物件內使用objectA和objectB//structObjectX{structObjectAobjA;structObjectBobjB;}避免使用指標關聯兩個資料結構。
如果使用指標關聯兩個資料結構，前面例項中的物件A和B將被分別分配和釋放。
這會增加額外開銷—我們要避免這種做法。
把帶指標的子物件嵌入父物件。
當物件中有指標時，則意味著物件中有動態元素（百分之八十）和沒有引用的新位置。
嵌入增加了位置從而減少了進一步分配/釋放的需求。
這將提高應用程式的效能。
合併小物件形成大物件（聚合）。
聚合減少分配和釋放的塊的數量。
如果有幾個開發者，各自開發設計的不同部分，則最終會有許多小物件需要合併。
整合的挑戰就是要找到正確的聚合邊界。
內聯緩衝區能夠滿足百分之八十的需要（aka80-20規則）。
個別情況下，需要記憶體緩衝區來儲存字串/二進位制資料，但事先不知道總位元組數。
估計並內聯一個大小能滿足百分之八十需要的緩衝區。
對剩餘的百分之二十，可以分配一個新的緩衝區和指向這個緩衝區的指標。
這樣，就減少分配和釋放呼叫並增加資料的位置空間，從根本上提高程式碼的效能。
在塊中分配物件（塊化）。
塊化是以組的方式一次分配多個物件的方法。
如果對列表的項連續跟蹤，例如對一個{名稱，值}對的列表，有兩種選擇：選擇一是為每一個“名稱-值”對分配一個節點；選擇二是分配一個能容納（如五個）“名稱-值”對的結構。
例如，一般情況下，如果儲存四對，就可減少節點的數量，如果需要額外的空間數量，則使用附加的連結串列指標。
塊化是友好的處理器快取記憶體，特別是對於L1-快取記憶體，因為它提供了增加的位置—不用說對於塊分配，很多資料塊會在同一個虛擬頁中。
正確使用_amblksiz。
C執行時(CRT)有它的自定義前端分配程式，該分配程式從後端（Win32堆）分配大小為_amblksiz的塊。
將_amblksiz設定為較高的值能潛在地減少對後端的呼叫次數。
這隻對廣泛使用CRT的程式適用。
使用上述技術將獲得的好處會因物件型別、大小及工作量而有所不同。
但總能在效能和可升縮性方面有所收穫。
另一方面，程式碼會有點特殊，但如果經過深思熟慮，程式碼還是很容易管理的。
其他提高效能的技術下面是一些提高速度的技術：使用WindowsNT5堆由於幾個同事的努力和辛勤工作，1998年初MicrosoftWindows(R)2000中有了幾個重大改進：改進了堆程式碼內的鎖定。
堆程式碼對每堆一個鎖。
全域性鎖保護堆資料結構，防止多執行緒式的使用。
但不幸的是，在高通訊量的情況下，堆仍受困於全域性鎖，導致高競爭和低效能。
Windows2000中，鎖內程式碼的臨界區將競爭的可能性減到最小,從而提高了可伸縮性。
使用“Lookaside”列表。
堆資料結構對塊的所有空閒項使用了大小在8到1,024位元組（以8-位元組遞增）的快速快取記憶體。
快速快取記憶體最初保護在全域性鎖內。
現在，使用lookaside列表來訪問這些快速快取記憶體空閒列表。
這些列表不要求鎖定，而是使用64位的互鎖操作，因此提高了效能。
內部資料結構演算法也得到改進。
這些改進避免了對分配快取記憶體的需求，但不排除其他的優化。
使用WindowsNT5堆評估您的程式碼；它對小於1,024位元組(1KB)的塊（來自前端分配程式的塊）是最佳的。
GlobalAlloc()和LocalAlloc()建立在同一堆上，是存取每個程序堆的通用機制。
如果希望獲得高的區域性效能，則使用Heap(R)API來存取每個程序堆，或為分配操作建立自己的堆。
如果需要對大塊操作，也可以直接使用VirtualAlloc()/VirtualFree()操作。
上述改進已在Windows2000beta2和WindowsNT4.0SP4中使用。
改進後，堆鎖的競爭率顯著降低。
這使所有Win32堆的直接使用者受益。
CRT堆建立於Win32堆的頂部，但它使用自己的小塊堆，因而不能從WindowsNT改進中受益。
（VisualC版本6.0也有改進的堆分配程式。
）使用分配快取記憶體分配快取記憶體允許快取記憶體分配的塊，以便將來重用。
這能夠減少對程序堆（或全域性堆）的分配/釋放呼叫的次數，也允許最大限度的重用曾經分配的塊。
另外，分配快取記憶體允許收集統計資訊,以便較好地理解物件在較高層次上的使用。
典型地，自定義堆分配程式在程序堆的頂部實現。
自定義堆分配程式與系統堆的行為很相似。
主要的差別是它在程序堆的頂部為分配的物件提供快取記憶體。
快取記憶體設計成一套固定大小（如32位元組、64位元組、128位元組等）。
這一個很好的策略，但這種自定義堆分配程式丟失與分配和釋放的物件相關的“語義資訊”。
與自定義堆分配程式相反，“分配快取記憶體”作為每類分配快取記憶體來實現。
除能夠提供自定義堆分配程式的所有好處之外，它們還能夠保留大量語義資訊。
每個分配快取記憶體處理程式與一個目標二進位制物件關聯。
它能夠使用一套引數進行初始化，這些參數列示併發級別、物件大小和保持在空閒列表中的元素的數量等。
分配快取記憶體處理程式物件維持自己的私有空閒實體池（不超過指定的閥值）並使用私有保護鎖。
合在一起，分配快取記憶體和私有鎖減少了與主系統堆的通訊量，因而提供了增加的併發、最大限度的重用和較高的可伸縮性。
需要使用清理程式來定期檢查所有分配快取記憶體處理程式的活動情況並回收未用的資源。
如果發現沒有活動，將釋放分配物件的池，從而提高效能。
可以稽核每個分配/釋放活動。
第一級資訊包括物件、分配和釋放呼叫的總數。
通過檢視它們的統計資訊可以得出各個物件之間的語義關係。
利用以上介紹的許多技術之一，這種關係可以用來減少記憶體分配。
分配快取記憶體也起到了除錯助手的作用，幫助您跟蹤沒有完全清除的物件數量。
通過檢視動態堆疊返回蹤跡和除沒有清除的物件之外的簽名，甚至能夠找到確切的失敗的呼叫者。
MP堆MP堆是對多處理器友好的分散式分配的程式包，在Win32SDK（WindowsNT4.0和更新版本）中可以得到。
最初由JVert實現，此處堆抽象建立在Win32堆程式包的頂部。
MP堆建立多個Win32堆，並試圖將分配呼叫分佈到不同堆，以減少在所有單一鎖上的競爭。
本程式包是好的步驟—一種改進的MP-友好的自定義堆分配程式。
但是，它不提供語義資訊和缺乏統計功能。
通常將MP堆作為SDK庫來使用。
如果使用這個SDK建立可重用元件，您將大大受益。
但是，如果在每個DLL中建立這個SDK庫，將增加工作設定。
重新思考演算法和資料結構要在多處理器機器上伸縮，則演算法、實現、資料結構和硬體必須動態伸縮。
請看最經常分配和釋放的資料結構。
試問，“我能用不同的資料結構完成此工作嗎？”例如，如果在應用程式初始化時載入了只讀項的列表，這個列表不必是線性連結的列表。
如果是動態分配的陣列就非常好。
動態分配的陣列將減少記憶體中的堆塊和碎片，從而增強效能。
減少需要的小物件的數量減少堆分配程式的負載。
例如，我們在伺服器的關鍵處理路徑上使用五個不同的物件，每個物件單獨分配和釋放。
一起快取記憶體這些物件，把堆呼叫從五個減少到一個，顯著減少了堆的負載，特別當每秒鐘處理1,000個以上的請求時。
如果大量使用“Automation”結構，請考慮從主線程式碼中刪除“AutomationBSTR”，或至少避免重複的BSTR操作。
（BSTR連線導致過多的重分配和分配/釋放操作。
）摘要對所有平臺往往都存在堆實現，因此有巨大的開銷。
每個單獨程式碼都有特定的要求，但設計能採用本文討論的基本理論來減少堆之間的相互作用。
評價您的程式碼中堆的使用。
改進您的程式碼，以使用較少的堆呼叫：分析關鍵路徑和固定資料結構。
在實現自定義的包裝程式之前使用量化堆呼叫成本的方法。
如果對效能不滿意，請要求OS組改進堆。
更多這類請求意味著對改進堆的更多關注。
要求C執行時組針對OS所提供的堆製作小巧的分配包裝程式。
隨著OS堆的改進，C執行時堆呼叫的成本將減小。
作業系統（WindowsNT家族）正在不斷改進堆。
請隨時關注和利用這些改進。
MuraliKrishnan是InternetInformationServer(IIS)組的首席軟體設計工程師。
從1.0版本開始他就設計IIS，併成功發行了1.0版本到4.0版本。
Murali組織並領導IIS效能組三年(1995-1998),從一開始就影響IIS效能。
他擁有威斯康星州Madison大學的M.S.和印度Anna大學的B.S.。
工作之外，他喜歡閱讀、打排球和家庭烹飪。
http://community.csdn.net/Expert/FAQ/FAQ_Index.asp?id=172835我在學習物件的生存方式的時候見到一種是在堆疊(stack)之中，如下CObjectobject;還有一種是在堆(heap)中如下CObject*pobject=newCObject();請問（1）這兩種方式有什麼區別？（2）堆疊與堆有什麼區別？？aboutstack,systemwillallocatememorytotheinstanceofobjectautomatically,andtotheheap,youmustallocatememorytotheinstanceofobjectwithnewormallocmanually.whenfunctionends,systemwillautomaticallyfreethememoryareaofstack,buttotheheap,youmustfreethememoryareamanuallywithfreeordelete,elseitwillresultinmemoryleak.3)棧記憶體分配運算內建於處理器的指令集中，效率很高，但是分配的記憶體容量有限。
4）堆上分配的記憶體可以有我們自己決定，使用非常靈活。
AdvertisementAdvertisement写评论取消回覆很抱歉，必須登入網站才能發佈留言。
近期文章前端下載文件的5種方法的對比2020.02.24全棧面試彙總週刊|第十一期2020.02.24Android自定義控件|小紅點的三種實現（上）2020.02.24從同一功能的八種實現，談談react中的邏輯複用進化過程2020.02.24Flutter完整開發實戰詳解(二十、AndroidPlatformView和鍵盤問題)2020.02.24Flutter混合開發實戰問題記錄（五）1.9.1hotfix打包aar差異2020.02.24刪庫了，我們一定要跑路嗎？2020.02.24http常被問到的知識總結2020.02.24🔥Webpack插件開發如此簡單！2020.02.24從零手寫一套Express的源碼2020.02.24AdvertisementAdvertisement
延伸文章資訊
- 11 記憶體布局
在圖中我們可以看到C 程式的記憶體配置可以分成5 個區塊(segment)，區 ... 反向的，例如heap 如果是往high address 長(大部分如此)，stack 就會往low.
- 2[探索5 分鐘] stack 與heap 的底層概念
讓我們從一段C 語言程式碼反窺stack 如何支持程式運行: #include <iostream> using namespace std; int main( int argc, char ...
- 3c 中堆和棧的的區別（stack vs heap） | 程式前沿
堆和棧的區別一、預備知識—程式的記憶體分配一個由c/C 編譯的程式佔用的記憶體分為以下幾個部分1、棧區（stack）— 由編譯器自動分配釋放， ...
- 4Stack vs Heap Memory Allocation - GeeksforGeeks
Memory in a C/C++/Java program can either be allocated on a stack or a heap. Prerequisite: Memory...
- 5Heap Memory in C Programming - Stack Overflow
The heap is the diametrical opposite of the stack. The heap is a large pool of memory that can be...
