Android亂彈onLowMemory()和onTrimMemory()

今天看郭哥的LitePal框架的源碼,剛打開LitePalApplication裡面的源碼看到了這樣一幕

@Override
	public void onLowMemory() {
		super.onLowMemory();
		mContext = getApplicationContext();
	}

不太懂郭哥的意思.之前依稀記得有人說起onLowMemory()和onTrimMemory(),於是乎,我就去查了查源碼,這篇博客就來亂彈一下onLowMemory()和onTrimMemory()

首先通過郭哥的那段代碼,就看到了,如下部分

public void onLowMemory() {
        Object[] callbacks = collectComponentCallbacks();
        if (callbacks != null) {
            for (int i=0; i

來了個接口回調,繼續看onLowMemory()

/**
     * This is called when the overall system is running low on memory, and
     * actively running processes should trim their memory usage.  While
     * the exact point at which this will be called is not defined, generally
     * it will happen when all background process have been killed.
     * That is, before reaching the point of killing processes hosting
     * service and foreground UI that we would like to avoid killing.
     *
     * 
You should implement this method to release
     * any caches or other unnecessary resources you may be holding on to.
     * The system will perform a garbage collection for you after returning from this method.
     * 
Preferably, you should implement {@link ComponentCallbacks2#onTrimMemory} from
     * {@link ComponentCallbacks2} to incrementally unload your resources based on various
     * levels of memory demands.  That API is available for API level 14 and higher, so you should
     * only use this {@link #onLowMemory} method as a fallback for older versions, which can be
     * treated the same as {@link ComponentCallbacks2#onTrimMemory} with the {@link
     * ComponentCallbacks2#TRIM_MEMORY_COMPLETE} level.
     */
    void onLowMemory();


我去,這麼多英文注釋,其實人家的英文注釋寫的很清楚了,onLowMemory()就是在內存比較緊張時,根據優先級把後台程序殺死時,系統回調他,它用在14之前,14之後就出現了onTrimMemory()

public void onTrimMemory(int level) {
        Object[] callbacks = collectComponentCallbacks();
        if (callbacks != null) {
            for (int i=0; i




/**
     * Level for {@link #onTrimMemory(int)}: the process is nearing the end
     * of the background LRU list, and if more memory isn't found soon it will
     * be killed.
     */
    static final int TRIM_MEMORY_COMPLETE = 80;
    
    /**
     * Level for {@link #onTrimMemory(int)}: the process is around the middle
     * of the background LRU list; freeing memory can help the system keep
     * other processes running later in the list for better overall performance.
     */
    static final int TRIM_MEMORY_MODERATE = 60;
    
    /**
     * Level for {@link #onTrimMemory(int)}: the process has gone on to the
     * LRU list.  This is a good opportunity to clean up resources that can
     * efficiently and quickly be re-built if the user returns to the app.
     */
    static final int TRIM_MEMORY_BACKGROUND = 40;
    
    /**
     * Level for {@link #onTrimMemory(int)}: the process had been showing
     * a user interface, and is no longer doing so.  Large allocations with
     * the UI should be released at this point to allow memory to be better
     * managed.
     */
    static final int TRIM_MEMORY_UI_HIDDEN = 20;

    /**
     * Level for {@link #onTrimMemory(int)}: the process is not an expendable
     * background process, but the device is running extremely low on memory
     * and is about to not be able to keep any background processes running.
     * Your running process should free up as many non-critical resources as it
     * can to allow that memory to be used elsewhere.  The next thing that
     * will happen after this is {@link #onLowMemory()} called to report that
     * nothing at all can be kept in the background, a situation that can start
     * to notably impact the user.
     */
    static final int TRIM_MEMORY_RUNNING_CRITICAL = 15;

    /**
     * Level for {@link #onTrimMemory(int)}: the process is not an expendable
     * background process, but the device is running low on memory.
     * Your running process should free up unneeded resources to allow that
     * memory to be used elsewhere.
     */
    static final int TRIM_MEMORY_RUNNING_LOW = 10;


    /**
     * Level for {@link #onTrimMemory(int)}: the process is not an expendable
     * background process, but the device is running moderately low on memory.
     * Your running process may want to release some unneeded resources for
     * use elsewhere.
     */
    static final int TRIM_MEMORY_RUNNING_MODERATE = 5;

    /**
     * Called when the operating system has determined that it is a good
     * time for a process to trim unneeded memory from its process.  This will
     * happen for example when it goes in the background and there is not enough
     * memory to keep as many background processes running as desired.  You
     * should never compare to exact values of the level, since new intermediate
     * values may be added -- you will typically want to compare if the value
     * is greater or equal to a level you are interested in.
     *
     * 
To retrieve the processes current trim level at any point, you can
     * use {@link android.app.ActivityManager#getMyMemoryState
     * ActivityManager.getMyMemoryState(RunningAppProcessInfo)}.
     *
     * @param level The context of the trim, giving a hint of the amount of
     * trimming the application may like to perform.  May be
     * {@link #TRIM_MEMORY_COMPLETE}, {@link #TRIM_MEMORY_MODERATE},
     * {@link #TRIM_MEMORY_BACKGROUND}, {@link #TRIM_MEMORY_UI_HIDDEN},
     * {@link #TRIM_MEMORY_RUNNING_CRITICAL}, {@link #TRIM_MEMORY_RUNNING_LOW},
     * or {@link #TRIM_MEMORY_RUNNING_MODERATE}.
     */
    void onTrimMemory(int level);
onTrimMemory(int level)是根據級別不同做不同的操作
TRIM_MEMORY_COMPLETE:


系統處於低內存的運行狀態中如果系統現在沒有內存回收你的應用將會第一個被殺掉. 你必須釋放掉所有非關鍵的資源從而恢復應用的狀態.
TRIM_MEMORY_MODERATE


 
系統處於低內存的運行狀態中並且你的應用處於緩存應用列表的中級階段. 如果系運行內存收到限制, 你的應用有被殺掉的風險.
TRIM_MEMORY_BACKGROUND:
    系統處於低內存的運行狀態中並且你的應用處於緩存應用列表的初級階段.  雖然你的應用不會處於被殺的高風險中, 但是系統已經開始清除緩存列表中的其它應用, 所以你必須釋放資源使你的應用繼續存留在列表中以便用戶再次回到你的應用時能快速恢復進行使用.
TRIM_MEMORY_UI_HIDDEN
     這個過程顯示到用戶界面,提示占用內存比較大的應用和ui即將被釋放,ui不可見
TRIM_MEMORY_RUNNING_CRITICAL
    應用處於運行狀態但是系統已經把大多數緩存應用殺掉了, 你必須釋放掉不是非常關鍵的資源, 如果系統不能回收足夠的運行內存, 系統會清除所有緩存應用並且會把正在活動的應用殺掉.
TRIM_MEMORY_RUNNING_LOW
    應用處於運行狀態並且不會被殺掉, 設備可以使用的內存非常低, 可以把不用的資源釋放一些提高性能(會直接影響程序的性能)
TRIM_MEMORY_RUNNING_MODERATE
   應用處於運行狀態並且不會被殺掉, 設備使用的內存比較低, 系統級會殺掉一些其它的緩存應用.





OnLowMemory()和OnTrimMemory()的比較

1，OnLowMemory被回調時，已經沒有後台進程；而onTrimMemory被回調時，還有後台進程。

2，OnLowMemory是在最後一個後台進程被殺時調用，一般情況是low memory killer 殺進程後觸發；而OnTrimMemory的觸發更頻繁，每次計算進程優先級時，只要滿足條件，都會觸發。

3，通過一鍵清理後，OnLowMemory不會被觸發，而OnTrimMemory會被觸發一次。