I'm investigating whether my Android activity has a memory leak using the Eclipse Memory Analyzer Tool (MAT). If the activity has a leak, I would expect dead instances to be hanging around on the heap, not getting garbage collected. To check this, I repeatedly start and stop (by pressing the Back button) the activity, and then inspect heap dumps using the MAT.
But I'm observing some strange behaviour that I cannot explain: the very first instance of the activity (started after a having done a force close) never gets garbage collected. However, subsequent instances do. I know this from inspection using the MAT tool: no matter how many times the activity is started and stopped, the MAT tool always shows two instances on the heap. The first instance belongs to the very first time the activity was started, while the second instance belongs to the most recently run activity.
Any idea as to what may be happening, and whether I should be worried about this wrt. memory leaks? Suggestions are much appreciated.
Just to close: seems that there are known issues with memory leaks in MapActivity subclasses. See e.g. code.google.com/p/android/issues/detail?id=2181. Haven't found a fix that works for me yet.
Related
I'd like to ask the community what they think about this behavior.
On my main activity I have one FloatingActionButton that when clicked will show a DialogFragment.
I followed Google's guidelines (I can't link it due to being a new user here at Stack Overflow) on how to properly create a DialogFragment so I believe I'm OK there. I've tested this behavior on fragments that use either onCreateDialog and onCreateView, and in both cases the results are the same.
When I click the button and I look at the memory usage, this is what I see:
Memory when fragment is first showed
So Android is allocating additional resources to compensate for showing a new fragment. That makes sense to me.
However, when I dismiss or cancel the dialog, the allocated memory doesn't drop.
When I open the same dialog using the same button, the allocated memory jumps again. I repeat this over and over (red arrows) until my allocated memory reaches just under 10MB and then (I believe) the Garbage Collector (blue arrow) kicks in and cleans up the app:
Memory after multiple showings
To me, this means I'm relying on the Garbage Collector to do the work for me and from what I understand that is not good practice.
Can anyone tell me if this is normal Android behavior, or is there something I'm doing wrong? If It isn't normal behavior, I will try to resolve the issue myself first before asking the community for further assistance (this is why I did not provide any code).
Thank you in advance.
I think this excerpt from this page sums up this behavior nicely.
Android does not offer swap space for memory, but it does use paging and memory-mapping (mmapping) to manage memory. This means that any memory you modify—whether by allocating new objects or touching mmapped pages—remains resident in RAM and cannot be paged out. So the only way to completely release memory from your app is to release object references you may be holding, making the memory available to the garbage collector. That is with one exception: any files mmapped in without modification, such as code, can be paged out of RAM if the system wants to use that memory elsewhere.
Basically, all you can do as an app developer is to release references to objects you allocate. So assuming you aren't keeping a reference to the object anywhere, like placing the fragment on the back stack for later use, the reference to the object should be released when the fragment is closed. At this point, it is available to the garbage collector to clear the previously allocated memory.
After that is done, it is up to the garbage collector to decide when to come in to action, so to say.
When running on Huawei G300 with Gingerbread, my app crashes after 5 minutes or so of usage during setContentView() as it runs out of memory.
Each individual page doesn't use much memory, but from some research it seems the memory accumulates in the back stack.
Following advice here, I've replaced all my calls to startActivity with a utility function that also calls finish().
Android: Clear the back stack
This works; but there is no more back stack - the back button immediately quits the app, which isn't what I wanted.
Is there a way to only finish() the applications when I actually do run out of memory, and is that a reasonable approach to take?
You should search for memory leaks. A good tool for that is MAT if you use eclipse. MAT is not that hard to handle and you can get quickly some very valuable information.
One of the most common mistakes I have seen on Android is to keep a reference on a context that is dead. For instance, having a singleton holding a reference on one of the activities you created. There is no real reason for an app to crash the memory if it is well coded.
The Android Activity Manager was designed to manage this exact problem. The OS is designed to kill activities in the background and then restore them using onSaveInstanceState and onRestoreInstanceState.
The fact that your app is accumulating memory usage over time indicates to me that you may have a Context leak somewhere (a static reference to a view, adapter, etc. that has a reference to a Context), or that you have a caching mechanism that's not adjusting to your memory heap, or some other situation that's causing the out of memory.
I highly doubt that it's the Activities in the Back Stack causing the Out of Memory.
Here's a great guide on tracking down memory leaks on Android:
http://android-developers.blogspot.com/2011/03/memory-analysis-for-android.html
Memory is a very tricky subject in Android.
Every app gets a heap memory limit depending on the device. This heap memory is the dalvik memory plus the native memory, and you can see it as the total column in the dumpsys meminfo results. The dalvik memory deals with everything except with the bitmaps, that are allocated in the native memory (this is true for Android versions before Honeycomb).
Having said that I can only answer to some of your questions:
As far as I know, Android will always allocate memory for Bitmaps, even if they are the same. Therefore, in your case, every activity allocates memory for your background.
I don't know if its better to work with themes, you'll have to try that.
On one hand, activities are not reclaimed while the device has enough memory to deal with the next activity. Every activity is pushed to a pile from where it is recovered when you pressed the back button. In case Android needs more memory it removes one activity from the pile deallocating its memory (going back to question number one, maybe this is the reason for not sharing memory). On the other hand, you can set the activities launchMode to change this behaviour (have a look here).
I think MAT doesn't show native memory data. Use dumpsys meminfo's native column to see how much allocated memory for Bitmaps you have.
I have had hard times dealing with OutOfMemory problems myself. Now I have a much more clear idea of how it works and I am able to work with large files without running out of memory. I would highly recommend these two resources that helped me a lot:
I'm working on a project dealing with map activities.
I was running a testing app consisting of a single activity, MaptestActivity, that extends MapActivity and does nothing else. I rotated the device more than ten times and I analyzed the heap dump with MAT. I noticed the existence of two instances of the main activity hanging around (a leak?). I re-tested the app with the same activity extending only Activity: the dump showed only one instance being kept by the system, the current one.
I'm attaching the screenshots of both cases. I'm not much into MAT, maybe I'm just misunderstanding the reults and everything works fine. Could you please shed some light on it?
With memory leak
Without memory leak
If you still have two activities in memory after rotating the device then you do have a memory leak. You can use MAT to see what is preventing that activity from being garbage collected by using the Histogram. Search on the class name to find it. Then right click on it and select list objects/with incoming references. That will list each occurrence of this object in memory. Right click on one of these objects and select Path to GC roots/exclude weak references. Now you should be able to see a hierarchy of objects, of which something is not getting cleaned up completely after the activity's onDestroy has finished. Things like hard references to a static context will cause this. To resolve some of our memory issues we've had to do things like use weakReferences where appropriate, and clean things up in onDestroy (like setting listeners to null).
Normally if your activities are not holding onto large objects like bitmaps you can "get away" with memory leaks since it would mean lots of app usage before you exceed the device's application heap size. But if say all of your activities hold onto a large bitmap, then leaking activities become much more of a big deal.
This is a good video: Memory Management for Android Apps
And a good article: Avoiding Memory Leaks
add the below line in for your activity in your manifeast file
android:configChanges="keyboardHidden|orientation"
My activity keeps a certain number of references to preview images from the camera in a Map object. This takes a lot of memory. I'm monitoring the memory usage using:
Runtime runtime = Runtime.getRuntime();
long allocated = runtime.totalMemory();
long free = runtime.freeMemory();
long used = allocated - free;
When I kill my app (back key), the activity is destroyed. When I start my app again, I can see that the memory was not cleared. The "used" figure starts at the same value and then goes up as new frames arrive.
When I look at the "dominator_tree" after I "Dump HPROF", I can see two instances of my activity, both taking a lot of memory.
When I override onDestroy() and I clear() the preview frames map object, this doesn't seem to happen.
I'm probably missing something here but I thought all memory should be deallocated after my activity is destroyed (after the garbage collection process), why do I have to manually clear() the map? Other objects I create don't seem to require this.
I tried setting android:launchMode="singleInstance" but this doesn't seem to have any affect.
Thanks!
in order to understand what's happening, in the dominator tree, on your activity click with the right button, look for PATH to GC ROOT and select the option that exclude weak/soft/phantom references. That would give you an idea why the system could not destroy your activity (if you are leaking something or what else)
Garbage collector will run as needed, at an indeterminate time chosen by the runtime. GC may or may not run when your application exists.
However, if your objects still stay in memory after GC is run it means you are leaking memory. You can check the logs in logcat while debugging to see when it is run.
For a good tutorial how to detecting and fixing leaks check Android Memory Management Video from Google.
I have an Android app that in the onCreate() method, preloads a lot of graphics.
When I test my app on my HTC Aria and launch it, it runs fine. However, if I press the back button to exit my app, and then launch the app again, it crashes with an OutOfMemoryError: bitmap size exceeds VM budget. If I then launch the app for the third time (right after it has crashed) it launches fine. Then if I close and re-launch it, it crashes again with out of memory. It continues this every-other-time-crashing pattern forever if I keep trying.
I checked to see what life cycle methods were being called and onStop() and onDestroy() are both being called when I exit the app, yet I have a feeling that something is not yet being cleaned up and that by "crashing" the app when I try to launch it the second time, it somehow free's the memory.
Any thoughts on what could be happening or how to remedy this? Please let me know if you need me to post more info. Thanks!
Info:
My app is fairly simple and only has 1 activity that plays some frame animations.
Maybe you are unnecessarily holding onto Context references? Check Avoiding memory leaks for some tips, as well as Attacking memory problems.
It sounds like something in the Activity life cycle is not quite right. Are you sure you have every start covered? http://developer.android.com/reference/android/app/Activity.html
You have onStop but do you have onDestroy? You're probably missing one of those that you need.
You may find some useful information the many answers to this question:
Strange out of memory issue while loading an image to a Bitmap object
Also, I second the "Avoiding Memory Leaks" blog post. Especially if you can trigger the same problem with orientation changes. Using "this" context when creating display objects is a sneaky way to leak the Activity context. In my own app, I managed to leak a whole chain of contexts, and would very rapidly run out of memory when doing orientation changes.