android 系統中可以在prop中配置dalvik堆的有關設定。具體設定由如下三個屬性來控制

-dalvik.vm.heapstartsize            

     堆分配的初始大小，調整這個值會影響到應用的流暢性和整體ram消耗。這個值越小，系統ram消耗越慢，

但是由於初始值較小，一些較大的應用需要擴張這個堆，從而引發gc和堆調整的策略，會應用反應更慢。

相反，這個值越大系統ram消耗越快，但是程式更流暢。

-dalvik.vm.heapgrowthlimit       

     受控情況下的極限堆（僅僅針對dalvik堆，不包括native堆）大小，dvm heap是可增長的，但是正常情況下

dvm heap的大小是不會超過dalvik.vm.heapgrowthlimit的值（非正常情況下面會詳細說明）。這個值控制那

些受控應用的極限堆大小，如果受控的應用dvm heap size超過該值，則將引發oom（out of memory）。

-dalvik.vm.heapsize 

    不受控情況下的極限堆大小，這個就是堆的最大值。不管它是不是受控的。這個值會影響非受控應用的dalvik

heap size。一旦dalvik heap size超過這個值，直接引發oom。

    用他們三者之間的關係做一個簡單的比喻：分配dalvik heap就好像去食堂打飯，有人飯量大，要吃三碗，有人飯量小，連一碗都吃不完。如果食堂按照三碗的標準來給每個人打飯，那絕對是鋪張浪費，所以食堂的策略就是先打一碗，湊合吃，不夠了自己再來加，設定堆大小也是一樣，先給一個合理值，湊合用，自己不夠了再跟系統要。食堂畢竟是做買賣的，如果很多人明顯吃不了那麼多，硬是一碗接著一碗。為了制止這種不合理的現象，食堂又定了一個策略，一般人就只能吃三碗。但是如果虎背熊腰的大漢確實有需要，可以吃上五碗，超過五碗就不給了（太虧本了）。

開始給一碗                                            對應       dalvik.vm.heapstartsize 

一般人最多吃三碗                                 對應       dalvik.vm.heapgrowthlimit

虎背熊腰的大漢最多能吃五碗              對應       dalvik.vm.heapsize

    在android開發中，如果要使用大堆。需要在manifest中指定android:largeHeap為true。這樣dvm heap最大可達dalvik.vm.heapsize。其中分配過程，可以在heap.cpp裡粗略看出一些原理：

1. /* Try as hard as possible to allocate some memory. 
2.  */
3. staticvoid *tryMalloc(size_t size)  
4. {  
5.     void *ptr;  
6.     /* Don't try too hard if there's no way the allocation is 
7.      * going to succeed.  We have to collect SoftReferences before 
8.      * throwing an OOME, though. 
9.      */
10.     if (size >= gDvm.heapGrowthLimit) {  
11.         LOGW("%zd byte allocation exceeds the %zd byte maximum heap size",  
12.              size, gDvm.heapGrowthLimit);  
13.         ptr = NULL;  
14.         goto collect_soft_refs;  
15.     }  
16. //TODO: figure out better heuristics
17. //    There will be a lot of churn if someone allocates a bunch of
18. //    big objects in a row, and we hit the frag case each time.
19. //    A full GC for each.
20. //    Maybe we grow the heap in bigger leaps
21. //    Maybe we skip the GC if the size is large and we did one recently
22. //      (number of allocations ago) (watch for thread effects)
23. //    DeflateTest allocs a bunch of ~128k buffers w/in 0-5 allocs of each other
24. //      (or, at least, there are only 0-5 objects swept each time)
25.     ptr = dvmHeapSourceAlloc(size);  
26.     if (ptr != NULL) {  
27.         return ptr;  
28.     }  
29.     /* 
30.      * The allocation failed.  If the GC is running, block until it 
31.      * completes and retry. 
32.      */
33.     if (gDvm.gcHeap->gcRunning) {  
34.         /* 
35.          * The GC is concurrently tracing the heap.  Release the heap 
36.          * lock, wait for the GC to complete, and retrying allocating. 
37.          */
38.         dvmWaitForConcurrentGcToComplete();  
39.         ptr = dvmHeapSourceAlloc(size);  
40.         if (ptr != NULL) {  
41.             return ptr;  
42.         }  
43.     }  
44.     /* 
45.      * Another failure.  Our thread was starved or there may be too 
46.      * many live objects.  Try a foreground GC.  This will have no 
47.      * effect if the concurrent GC is already running. 
48.      */
49.     gcForMalloc(false);  
50.     ptr = dvmHeapSourceAlloc(size);  
51.     if (ptr != NULL) {  
52.         return ptr;  
53.     }  
54.     /* Even that didn't work;  this is an exceptional state. 
55.      * Try harder, growing the heap if necessary. 
56.      */
57.     ptr = dvmHeapSourceAllocAndGrow(size);  
58.     if (ptr != NULL) {  
59.         size_t newHeapSize;  
60.         newHeapSize = dvmHeapSourceGetIdealFootprint();  
61. //TODO: may want to grow a little bit more so that the amount of free
62. //      space is equal to the old free space + the utilization slop for
63. //      the new allocation.
64.         LOGI_HEAP("Grow heap (frag case) to "
65.                 "%zu.%03zuMB for %zu-byte allocation",  
66.                 FRACTIONAL_MB(newHeapSize), size);  
67.         return ptr;  
68.     }  
69.     /* Most allocations should have succeeded by now, so the heap 
70.      * is really full, really fragmented, or the requested size is 
71.      * really big.  Do another GC, collecting SoftReferences this 
72.      * time.  The VM spec requires that all SoftReferences have 
73.      * been collected and cleared before throwing an OOME. 
74.      */
75. //TODO: wait for the finalizers from the previous GC to finish
76. collect_soft_refs:  
77.     LOGI_HEAP("Forcing collection of SoftReferences for %zu-byte allocation",  
78.             size);  
79.     gcForMalloc(true);  
80.     ptr = dvmHeapSourceAllocAndGrow(size);  
81.     if (ptr != NULL) {  
82.         return ptr;  
83.     }  
84. //TODO: maybe wait for finalizers and try one last time
85.     LOGE_HEAP("Out of memory on a %zd-byte allocation.", size);  
86. //TODO: tell the HeapSource to dump its state
87.     dvmDumpThread(dvmThreadSelf(), false);  
88.     return NULL;  
89. }  

這裡分為如下幾個動作

1  首先判斷一下需要申請的size是不是過大，如果申請的size超過了堆的最大限制，則轉入步驟6

2  嘗試分配，如果成功則返回，失敗則轉入步驟3

3  判斷是否gc正在進行垃圾回收，如果正在進行則等待回收完成之後，嘗試分配。如果成功則返回，失敗則轉入步驟4

4  自己啟動gc進行垃圾回收，這裡gcForMalloc的引數是false。所以不會回收軟引用，回收完成後嘗試分配，如果成功則返回，失敗則轉入步驟5

5  呼叫dvmHeapSourceAllocAndGrow嘗試分配，這個函式會擴張堆。所以heap startup的時候可以給一個比較小的初始堆，實在不夠用再呼叫它進行擴張

6  進入回收軟引用階段，這裡gcForMalloc的引數是ture，所以需要回收軟引用。然後呼叫dvmHeapSourceAllocAndGrow嘗試分配，如果失敗則丟擲OOM 

如果設定了largeHeap，具體流程從解析apk開始，原始碼位於PackagePaser.java中，其中parseApplication函式負責解析apk。其中有一個小段程式碼如下：

1. if (sa.getBoolean(  
2.               com.android.internal.R.styleable.AndroidManifestApplication_largeHeap,  
3.               false)) {  
4.           ai.flags |= ApplicationInfo.FLAG_LARGE_HEAP;  
5.       }  

1. if ((data.appInfo.flags&ApplicationInfo.FLAG_LARGE_HEAP) != 0) {  
2.             dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();  
3.         }  

1. /* 
2.  * Removes any growth limits.  Allows the user to allocate up to the 
3.  * maximum heap size. 
4.  */
5. void dvmClearGrowthLimit()  
6. {  
7.     HS_BOILERPLATE();  
8.     dvmLockHeap();  
9.     dvmWaitForConcurrentGcToComplete();  
10.     gHs->growthLimit = gHs->maximumSize;  
11.     size_t overhead = oldHeapOverhead(gHs, false);  
12.     gHs->heaps[0].maximumSize = gHs->maximumSize - overhead;  
13.     gHs->heaps[0].limit = gHs->heaps[0].base + gHs->heaps[0].maximumSize;  
14.     dvmUnlockHeap();  
15. }