On the Android platform, application OOM exceptions are always worthy of attention. Usually this is also one of the key points in the program. Now I will give a brief introduction on how to solve OOM.
First of all, OOM is memory overflow, that is, Out Of Memory. That is to say, the memory footprint exceeds the maximum allocated by the VM.
How to solve OOM? Usually, OOM occurs when a large amount of memory is needed (creating or parsing Bitmap, allocating extra large arrays, etc.). In such a situation, OOM may occur. As far as I know now, most OOMs are because Bitmap is too large. So, here I will focus on how to solve Bitmap's OOM. In fact, the most issuing is to only load Bitmap within the visible range. Imagine this situation. In GridView or ListView, the data volume is 5,000, and only 20 elements are displayed on each screen. So it is invisible. We do not need to save the Bitmap inside. So we just keep the visible Bitmap in memory, and those that are invisible will be released. When the element slides out, then load the Bitmap.
Here I have two ways to avoid OOM.
1. Actively release Bitmap's memory
I briefly mentioned this method, and I don’t recommend it very much. This is also the method I used at the beginning, but in the end it proved that it is not the best. (Not recommended)
ItsEssential ideasyes:
1. Only load Bitmap in visible areas
2. No loading when sliding
3. After stopping the slide (Idle), start reloading the pictures of the visible area
4. Release the inner part of the Bitmap that slides out of the visible area.
It is more complicated:
1. We need to listen to the sliding event of GridView/ListView. This is very simple to do. AbsListView#setOnScrollListener(OnScrollListener l)
2. Actively call the Bitmap#recycle() method, which will cause a problem. You must determine whether the Bitmap is referenced by a View (ImageView, etc.). If it is referenced, we cannot simply call the recycle() method, which will cause an exception, saying that the View uses a Bitmap that has been recycled.
3. We must design our own thread to control start/pause, etc., because the sliding state of GridView/ListView may change constantly, that is, sliding->stop->slide. This state may change constantly, which will lead to the logic in the run() method in our thread being more complicated. Once it is complicated, there may be more problems.
Based on the above points, this method is not the best, so it is not recommended.
2. Design Cache
I think this method is a better one. It first uses cache. I think cache is a very important thing. Bitmap's memory is placed in a separate place to manage it. This place is cache, and its capacity is certain. We may constantly add elements to this cache or remove elements.
To better explain this method, I would like to introduce LruCache first.
LruCache
1. This is actually a LinkedHashMap. When a value is accessed at any time, it will be moved to the starting position of the queue. Therefore, this is also the reason why LinkedHashMap is used, because you need to do frequent movement operations. In order to improve performance, you need to use LinkedHashMap. When the cache is full, add a value to the cache, and the last value in the queue will be removed from the queue, and this value may be collected by GC.
2. If we want to actively free memory, it is OK. We can rewrite the entryRemoved(Boolean, K, V, V) method.
3. This class is thread-safe. There will be no problem when using this class under multi-threading.
synchronized (cache) {
if ((key) == null) {
(key, value);
}}
4. LruCache's APILevel is 12, which means that we cannot use the following in SDK 2. But it doesn't matter. The source code of LruCache is not complicated. We can just copy it to our own project directory.
AsyncTask<>
This class is also a very important and commonly used class. It encapsulates Thread and Handler, which makes it more convenient for us to use. Don't pay attention to Handler. We know that the UI cannot be updated in the background thread. In many cases, after we finish a thing in the background thread, we usually update the UI. The general approach is to send a message to the Handler associated with the UI thread, and process the message in the Handler to update the UI. After using AsyncTask, we don't need to pay attention to Handler.There are several important methods for this class:
1), onPreExecute(): Called in the UI thread, it will be called immediately after the task is executed. In this method, we are usually used to create a task, such as displaying a waiting dialog box to notify the user.
2), doInBackground(Params...): This method can be seen from the name. It runs in the background thread. In this method, it does time-consuming things, such as downloading and accessing the network, operating files, etc. In this method, we can call publishProgress(Progress...) to call the progress of the current task. After calling this method, the corresponding onProgressUpdate(Progress...) method will be called, which runs in the UI thread.
3) onProgressUpdate(Progress...): Runs in the UI thread, after calling the publishProgress() method. This method is used to display any form of progress on the UI. For example, you can display a waiting dialog box, a text log, or a toast dialog box.
4), onPostExecute(Result): When the task is called after it is finished, it runs in the UI thread.
5) To cancel a task, we can call cancel(Boolean) at any time to cancel a task. When the cancel() method is called, the onCancelled(Object) method will be called, and the onPostExecute(Object) method will not be called. In the doInBackground(Object[]) method, we can use the isCancelled() method to check whether the task is cancelled.
6) Some rules
AsyncTask instance must be created in UI thread
The execute(Params...) method must be called in the UI thread.
You do not need to manually call the onPreExecute(), onPostExecute(), doInBackground(), onProgressUpdate() methods.
A task can only be executed once.
Overall idea
1. Always get the Bitmap from the cache. If you get the Bitmap, set the Bitmap directly to the ImageView.
2. If the cache does not exist, then start a task to load (may come from the file or from the network).
3. Each ImageView may bind a task, so this ImageView must provide a method to obtain the task associated with it. Why do you need to do this? Because before binding a task to an ImageView, the original task must be cancelled.
The above is the method to solve the OOM exception of the application, and I hope it will be helpful to everyone's learning.