我 們知道，android程式記憶體一般限制在16M，當然也有24M的，而android程式記憶體被分為2部分：native和dalvik，dalvik 就是我們平常說的java堆，我們建立的物件是在這裡面分配的，而bitmap是直接在native上分配的，對於記憶體的限制是 native+dalvik 不能超過最大限制。

1.單個app 記憶體限制大小

1. ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
2.         activityManager.getMemoryClass();  

2."/proc/meminfo"  系統記憶體資訊檔案【整個系統的記憶體情況】

3.ActivityManager.MemoryInfo【整個系統】

availMem         剩餘記憶體

threshold         臨界值 【超過次值就開始殺死後臺服務和沒有關聯的程序】

lowMemory     低記憶體狀態

4.android.os.Debug

getNativeHeapFreeSize()

getNativeHeapAllocatedSize()

getNativeHeapSize()

5.android.os.Debug.MemoryInfo【當前程序的記憶體情況】

6.Runtime

totalMemory() freeMemory()

maxMemory()

7.VMRuntime

getTargetHeapUtilization()

getMinimumHeapSize()

getExternalBytesAllocated()   應該是外部分配的記憶體Native記憶體

系統GC釋放的記憶體提示

一般在LOG裡面顯示如下： 09-28 17:16:37.543: DEBUG/dalvikvm(21466): GC_EXTERNAL_ALLOC freed 390 objects / 45656 bytes in 50ms
09-28 17:16:40.513: DEBUG/dalvikvm(3267): GC_EXPLICIT freed 4501 objects / 251624 bytes in 67ms

EXPLICIT：Free的記憶體是VM中java使用的記憶體 即 heap mem

EXTERNA：Free的記憶體是VM中通過JNI的Native類中的malloc分配的記憶體 例如 Bitmap 和一些 Cursor

在Davilk中，給一個程式分配的記憶體根據機型廠商的不同，而不同，現在的大部分的是32M了，而在VM內部會把這些記憶體分成java使用的記憶體和 Native使用的記憶體，它們之間是不能共享的，就是說當你的Native記憶體用完了，現在Java又有空閒的記憶體，這時Native會重新像VM申請，而不是直接使用java的。

例如上邊的例子

explicit 3411K/6663K

external 24870K/26260K

如果這時需要建立一個2M的

Bitmap，

 

Native現有記憶體26260-24870=1390K<2048k,因此他就會向Vm申請記憶體，雖然java空閒的記憶體是

 

6663-3411=3252>2048,但這部分記憶體Native是不能使用。

 

但是你現在去申請2M的Native記憶體，VM會告訴你無法分配的，因為現在已使用的記憶體已經接近峰值了32M(26260+6663=32923 )，所以現在就會成force close 報OOM。

所以現在我們要檢查我們的native記憶體的使用情況來避免OOM。

ps: http://stackoverflow.com/questions/2298208/how-to-discover-memory-usage-of-my-application-in-android#2299813

三、通過Android系統提供的Runtime類，執行adb 命令(top,procrank,ps...等命令)查詢

記憶體耗用：VSS/RSS/PSS/USS
Terms
? VSS - Virtual Set Size 虛擬耗用記憶體（包含共享庫佔用的記憶體）
? RSS - Resident Set Size 實際使用實體記憶體（包含共享庫佔用的記憶體）
? PSS - Proportional Set Size 實際使用的實體記憶體（比例分配共享庫佔用的記憶體）
? USS - Unique Set Size 程序獨自佔用的實體記憶體（不包含共享庫佔用的記憶體）
一般來說記憶體佔用大小有如下規律：VSS >= RSS >= PSS >= USS

檢視每個程序及其記憶體狀況

	private void getRunningAppProcessInfo() {
		mActivityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);

		// 獲得系統里正在執行的所有程序
		List<RunningAppProcessInfo> runningAppProcessesList = mActivityManager
				.getRunningAppProcesses();

		for (RunningAppProcessInfo runningAppProcessInfo : runningAppProcessesList) {
			// 程序ID號
			int pid = runningAppProcessInfo.pid;
			// 使用者ID
			int uid = runningAppProcessInfo.uid;
			// 程序名
			String processName = runningAppProcessInfo.processName;
			// 佔用的記憶體
			int[] pids = new int[] { pid };
			Debug.MemoryInfo[] memoryInfo = mActivityManager
					.getProcessMemoryInfo(pids);
			int memorySize = memoryInfo[0].dalvikPrivateDirty;
			st = st + "processName=" + processName + ",pid=" + pid + ",uid="
					+ uid + ",memorySize=" + memorySize + "kb" + "\n";
			System.out.println("processName=" + processName + ",pid=" + pid
					+ ",uid=" + uid + ",memorySize=" + memorySize + "kb");
		}
		
	}

檢視總記憶體：

	public long getmem_TOLAL() {
		long mTotal;
		// /proc/meminfo讀出的核心資訊進行解釋
		String path = "/proc/meminfo";
		String content = null;
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader(path), 8);
			String line;
			if ((line = br.readLine()) != null) {
				content = line;
			}

		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		// beginIndex
		int begin = content.indexOf(':');
		// endIndex
		int end = content.indexOf('k');
		// 擷取字串資訊
		content = content.substring(begin + 1, end).trim();
		mTotal = Integer.parseInt(content);
		return mTotal;
	}

檢視記憶體資訊（該api較新）：

	public long getmem_UNUSED(Context mContext) {
		long MEM_UNUSED;
		// 得到ActivityManager
		ActivityManager am = (ActivityManager) mContext
				.getSystemService(Context.ACTIVITY_SERVICE);
		// 建立ActivityManager.MemoryInfo物件
		ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
		am.getMemoryInfo(mi);
		textView3.setText("totalMen:" + mi.totalMem / 1024 + "\n"
				+ "threshold:" + mi.threshold / 1024 + "\n" + "availMem:"
				+ mi.availMem / 1024 + "\n");
		// 取得剩餘的記憶體空間
		MEM_UNUSED = mi.availMem / 1024;
		return MEM_UNUSED;
	}

檢視app記憶體：

	ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
	int i=manager.getMemoryClass();
	textView.setText("\n"+"app:"+i);

像Linux這種現代作業系統的記憶體使用是很複雜的，因此很難準確的知道你的應用程式使用了好多記憶體。 檢視記憶體使用的方式有很多種，但是各個方式檢視到的結果可能會有微略不同。 方式一，Running services 通過手機上Running services的Activity檢視，可以通過Setting->Applications->Running services進。 ActivityManager.getMemoryInfo()主要是用於得到當前系統剩餘記憶體的及判斷是否處於低記憶體執行。 例項1：     private void displayBriefMemory() {      final ActivityManager activityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);             ActivityManager.MemoryInfo info = new ActivityManager.MemoryInfo();            activityManager.getMemoryInfo(info);             Log.i(tag,"系統剩餘記憶體:"+(info.availMem >> 10)+"k");            Log.i(tag,"系統是否處於低記憶體執行："+info.lowMemory);         Log.i(tag,"當系統剩餘記憶體低於"+info.threshold+"時就看成低記憶體執行");     }  ActivityManager.getMemoryInfo()是用ActivityManager.MemoryInfo返回結果，而不是Debug.MemoryInfo，他們不一樣的。 ActivityManager.MemoryInfo只有三個Field: availMem:表示系統剩餘記憶體 lowMemory：它是boolean值，表示系統是否處於低記憶體執行 hreshold：它表示當系統剩餘記憶體低於好多時就看成低記憶體執行 方式三，在程式碼中使用Debug的getMemoryInfo(Debug.MemoryInfo memoryInfo)或ActivityManager的MemoryInfo[] getProcessMemoryInfo(int[] pids) 該方式得到的MemoryInfo所描述的記憶體使用情況比較詳細.資料的單位是KＢ. MemoryInfo的Field如下 dalvikPrivateDirty： The private dirty pages used by dalvik。 dalvikPss ：The proportional set size for dalvik. dalvikSharedDirty ：The shared dirty pages used by dalvik. nativePrivateDirty ：The private dirty pages used by the native heap. nativePss ：The proportional set size for the native heap. nativeSharedDirty ：The shared dirty pages used by the native heap. otherPrivateDirty ：The private dirty pages used by everything else. otherPss ：The proportional set size for everything else. otherSharedDirty ：The shared dirty pages used by everything else. Android和Linux一樣有大量記憶體在程序之間程序共享。某個程序準確的使用好多記憶體實際上是很難統計的。 因為有paging out to disk（換頁），所以如果你把所有對映到程序的記憶體相加，它可能大於你的記憶體的實際物理大小。 dalvik：是指dalvik所使用的記憶體。 native：是被native堆使用的記憶體。應該指使用C\C++在堆上分配的記憶體。 other:是指除dalvik和native使用的記憶體。但是具體是指什麼呢？至少包括在C\C++分配的非堆記憶體，比如分配在棧上的記憶體。puzlle! private:是指私有的。非共享的。 share:是指共享的記憶體。 PSS：實際使用的實體記憶體（比例分配共享庫佔用的記憶體） Pss：它是把共享記憶體根據一定比例分攤到共享它的各個程序來計算所得到程序使用記憶體。網上又說是比例分配共享庫佔用的記憶體，那麼至於這裡的共享是否只是庫的共享，還是不清楚。  PrivateDirty：它是指非共享的，又不能換頁出去（can not be paged to disk ）的記憶體的大小。比如Linux為了提高分配記憶體速度而緩衝的小物件，即使你的程序結束，該記憶體也不會釋放掉，它只是又重新回到緩衝中而已。 SharedDirty:參照PrivateDirty我認為它應該是指共享的，又不能換頁出去（can not be paged to disk ）的記憶體的大小。比如Linux為了提高分配記憶體速度而緩衝的小物件，即使所有共享它的程序結束，該記憶體也不會釋放掉，它只是又重新回到緩衝中而已。 具體程式碼請參考例項1 注意１：MemoryInfo所描述的記憶體使用情況都可以通過命令adb shell "dumpsys meminfo %curProcessName%" 得到。 注意２：如果想在程式碼中同時得到多個程序的記憶體使用或非本程序的記憶體使用情況請使用ActivityManager的MemoryInfo[] getProcessMemoryInfo(int[] pids)， 否則Debug的getMemoryInfo(Debug.MemoryInfo memoryInfo)就可以了。 注意３：可以通過ActivityManager的List<<a href="http://developer.android.com/reference/android/app/ActivityManager.RunningAppProcessInfo.html" rel="nofollow" style="color: rgb(207, 121, 28); text-decoration: none;">ActivityManager.RunningAppProcessInfo> ()得到當前所有執行的程序資訊。 注意4：資料的單位是KB. 方式4、使用Debug的getNativeHeapSize ()，getNativeHeapAllocatedSize ()，getNativeHeapFreeSize ()方法。 該方式只能得到Native堆的記憶體大概情況，資料單位為位元組。 Returns the amount of allocated memory in the native heap. 返回的是當前程序navtive堆中已使用的記憶體大小
static long () Returns the amount of free memory in the native heap. 返回的是當前程序navtive堆中已經剩餘的記憶體大小 static long () Returns the size of the native heap. 返回的是當前程序navtive堆本身總的記憶體大小 示例程式碼：           Log.i(tag,"NativeHeapSizeTotal:"+(Debug.getNativeHeapSize()>>10));           Log.i(tag,"NativeAllocatedHeapSize:"+(Debug.getNativeHeapAllocatedSize()>>10));           Log.i(tag,"NativeAllocatedFree:"+(Debug.getNativeHeapFreeSize()>>10)); 注意：DEBUG中居然沒有與上面相對應的關於dalvik的函式。 方式五、使用dumpsys meminfo命令。 我們可以在adb shell 中執行dumpsys meminfo命令來得到程序的記憶體資訊。在該命令的後面要加上程序的名字，以確定是哪個程序。 比如"adb shell dumpsys meminfo com.teleca.robin.test" 將得到com.teleca.robin.test程序使用的記憶體的資訊:  Applications Memory Usage (kB): Uptime: 12101826 Realtime: 270857936 ** MEMINFO in pid 3407 [com.teleca.robin.test] **                     native   dalvik    other    total size:     3456     3139      N/A     6595 allocated:     3432     2823      N/A     6255 free:       23      316      N/A      339 (Pss):      724     1101     1070     2895 (shared dirty):     1584     4540     1668     7792 (priv dirty):      644      608      688     1940  Objects            Views:        0        ViewRoots:        0      AppContexts:        0       Activities:        0           Assets:        3    AssetManagers:        3    Local Binders:        5    Proxy Binders:       11 Death Recipients:        0  OpenSSL Sockets:        0  SQL             heap:        0       memoryUsed:        0 pageCacheOverflo:        0  largestMemAlloc:        0  Asset Allocations     zip:/data/app/com.teleca.robin.test-1.apk:/resources.arsc: 1K  "size" 表示的是總記憶體大小（kb）。, "allocated" 表示的是已使用了的記憶體大小（kb），, "free"表示的是剩餘的記憶體大小（kb）, 更多的可以參照方式三和方式四中的描述 現在已經有了自動提取彙總dumpsys meminfo資訊的工具，具體請參照《》及其系列文章。 方式六、使用 "adb shell procrank"命令 如果你想檢視所有程序的記憶體使用情況，可以使用"adb shell procrank"命令。命令返回將如下：   PID      Vss      Rss      Pss      Uss  cmdline   188   75832K   51628K   24824K   19028K  system_server   308   50676K   26476K    9839K    6844K  system_server  2834   35896K   31892K    9201K    6740K  com.sec.android.app.twlauncher   265   28536K   28532K    7985K    5824K  com.android.phone   100   29052K   29048K    7299K    4984K  zygote   258   27128K   27124K    7067K    5248K  com.swype.android.inputmethod   270   25820K   25816K    6752K    5420K  com.android.kineto  1253   27004K   27000K    6489K    4880K  com.google.android.voicesearch  2898   26620K   26616K    6204K    3408K  com.google.android.apps.maps:FriendService   297   26180K   26176K    5886K    4548K  com.google.process.gapps  3157   24140K   24136K    5191K    4272K  android.process.acore  2854   23304K   23300K    4067K    2788K  com.android.vending  3604   22844K   22840K    4036K    3060K  com.wssyncmldm   592   23372K   23368K    3987K    2812K  com.google.android.googlequicksearchbox  3000   22768K   22764K    3844K    2724K  com.tmobile.selfhelp   101    8128K    8124K    3649K    2996K  /system/bin/mediaserver  3473   21792K   21784K    3103K    2164K  com.android.providers.calendar 3407   22092K   22088K    2982K    1980K  com.teleca.robin.test  2840   21380K   21376K    2953K    1996K  com.sec.android.app.controlpanel ...................................................................................................................... 注意1：這裡的PSS和方式四PSS的total並不一致，有細微的差別。為什麼呢？這是因為procrank 命令和meminfo命令使用的核心機制不太一樣，所以結果會有細微差別 注意2：這裡的Uss 和方式四的Priv Dirtyd的total幾乎相等.他們似乎表示的是同一個意義。但是現在得到的關於它們的意義的解釋卻不太相同。難道這裡Private的都是dirty(這裡指不能換頁)? Puzzle! 方式七、使用"adb shell cat /proc/meminfo" 命令。 該方式只能得出系統整個記憶體的大概使用情況。 MemTotal:         395144 kB  MemFree:          184936 kB  Buffers:             880 kB  Cached:            84104 kB  SwapCached:            0 kB  ................................................................................................ MemTotal ：可供系統和使用者使用的總記憶體大小 (它比實際的實體記憶體要小，因為還有些記憶體要用於radio, DMA buffers, 等).  MemFree：剩餘的可用記憶體大小。這裡該值比較大，實際上一般Android system 的該值通常都很小，因為我們儘量讓程序都保持執行，這樣會耗掉大量記憶體。 Cached: 這個是系統用於檔案緩衝等的記憶體. 通常systems需要20MB 以避免bad paging states;。當記憶體緊張時，the Android out of memory killer將殺死一些background程序，以避免他們消耗過多的cached RAM ，當然如果下次再用到他們，就需要paging. 那麼是說background程序的記憶體包含在該項中嗎？ 方式八，使用“adb shell ps -x”命令 該方式主要得到的是記憶體資訊是VSIZE 和RSS。 USER     PID   PPID  VSIZE  RSS     WCHAN    PC         NAME .........................省略................................. app_70    3407  100   267104 22056 ffffffff afd0eb18 S com.teleca.robin.test (u:55, s:12) app_7     3473  100   268780 21784 ffffffff afd0eb18 S com.android.providers.calendar (u:16, s:8) radio     3487  100   267980 21140 ffffffff afd0eb18 S com.osp.app.signin (u:11, s:12) system    3511  100   273232 22024 ffffffff afd0eb18 S com.android.settings (u:11, s:4) app_15    3546  100   267900 20300 ffffffff afd0eb18 S com.sec.android.providers.drm (u:15, s:6) app_59    3604  100   272028 22856 ffffffff afd0eb18 S com.wssyncmldm (u:231, s:54) root      4528  2     0      0     c0141e4c 00000000 S flush-138:13 (u:0, s:0) root      4701  152   676    336   c00a68c8 afd0e7cc S /system/bin/sh (u:0, s:0) root      4702  4701  820    340   00000000 afd0d8bc R ps (u:0, s:5) VSZIE:意義暫時不明。 注意1：由於RSS的價值不是很大，所以一般不用。

例項1

    int cnt=0;

    final static int kBufferMinSize=1000;

    final static int kBufferMaxSize=2000;

    StringBuffer strBuffer=new StringBuffer(kBufferMinSize);

    StringBuffer strBuffer2=new StringBuffer(kBufferMinSize);

    StringBuffer strBuffer3=new StringBuffer(kBufferMinSize);

    StringBuffer strBufferNativePss=new StringBuffer(kBufferMinSize);

    StringBuffer strBufferDalvikPss=new StringBuffer(kBufferMinSize);

    StringBuffer strBufferOtherPss=new StringBuffer(kBufferMinSize);

    Debug.MemoryInfo memoryInfo=new Debug.MemoryInfo();

    final static String tag="robin";

void printMemory()

    {

    long totalMemory=Runtime.getRuntime().totalMemory();

          long freeMemory=Runtime.getRuntime().freeMemory();

          long usedMemory=(totalMemory-freeMemory)>>10;

          totalMemory=totalMemory>>10;

          freeMemory=freeMemory>>10;

          if(strBuffer.length()>kBufferMaxSize)

          {

                strBuffer.delete(0,strBuffer.length());

                strBuffer2.delete(0,strBuffer2.length());

                strBuffer3.delete(0,strBuffer3.length());

                strBufferNativePss.delete(0,strBufferNativePss.length());

                strBufferDalvikPss.delete(0,strBufferDalvikPss.length());

          }

          strBuffer.append(usedMemory+",");

          strBuffer2.append(totalMemory+",");

          strBuffer3.append((Debug.getNativeHeapSize()>>10)+",");

          Debug.getMemoryInfo(memoryInfo);

          strBufferNativePss.append((memoryInfo.nativePss)+",");

          strBufferDalvikPss.append((memoryInfo.dalvikPss)+",");

          if(cnt++==0)

          {

                Log.i(tag,"usedMemory:"+strBuffer.toString());

                Log.i(tag,"totalMemory:"+strBuffer2.toString());

                Log.i(tag,"NativeHeapSize:"+strBuffer3.toString());

                Log.i(tag,"Native PSS:"+strBufferNativePss.toString());

                Log.i(tag,"Dalvik PSS:"+strBufferDalvikPss.toString());

          }    

    }

注意，對於輸出的記憶體資訊日誌，我們稍作編輯就可以用於在excel產中圖表，比便更直觀的進行分析。