Nonetheless we still sometimes have crashes with OutOfMemory. Very wheres the rubbish collector?
Im attending concentrate on among instances when larger objects in storage cant end up being cleared for a lengthy period. This example is not fundamentally a memory leak things can be amassed sooner or later so we sometimes dismiss it. That isn’t advisable as it can certainly occasionally cause OOM errors.
The case Im describing is the Handler leak, and that’s typically identified as a warning by Lint.
Important Example
This is a really basic activity. Notice that this private Runnable has been uploaded to your Handler with a long wait. Well manage it and rotate the phone few hours, next dispose of mind and study it.
We have seven activities in storage today. This might be not good. Lets see why GC struggles to remove all of them.
The question I made to get a summary of all strategies remaining in memory space was created in OQL (item Query vocabulary), which can be easy, but powerful.
As you can tell, airg app among the many activities are referenced by this$0 . This might be an indirect guide through the unknown class toward proprietor lessons. This$0 are referenced by callback , which will be after that referenced by a chain of then s of information back again to the key bond.
When you make a non-static lessons in the holder course, coffee creates an indirect mention of the particular owner
After you post Runnable or Message into Handler , it’s next kept in set of information commands referenced from LooperThread till the message was accomplished. Posting delayed messages is actually an obvious drip for at least committed of wait worth. Posting without delay causes a short-term leak too if the queue of information try huge.
Fixed Runnable Remedy
Lets you will need to over come a mind drip through getting rid of this$0 , by transforming the unknown class to static.
Operate, rotate and acquire the storage dump.
What, once more? Lets see who helps to keep discussing strategies .
Take a good look at the base of the tree activity is actually stored as a mention of the mContext inside mTextView of one’s DoneRunnable lessons. Utilizing static interior courses just isn’t adequate to manage mind leaks, nevertheless. We need to carry out additional.
Fixed Runnable With WeakReference
Lets continue using iterative solutions and obtain rid of the mention of the TextView, which will keep task from getting destroyed.
Note that our company is maintaining WeakReference to TextView, and lets run, turn and dump storage.
Be cautious with WeakReferences. They could be null any kind of time moment, thus resolve all of them 1st to a nearby variable (hard resource) right after which see to null before incorporate.
Hooray! One task instance. This eliminates the mind difficulty.
Thus with this means we must:
- Utilize static interior tuition (or outside courses)
- Utilize WeakReference to things manipulated from Handler / Runnable
If you examine this laws on the first code, many times a significant difference in readability and signal approval. The first laws is a lot shorter and much clearer, and youll note that eventually, book in textView will likely be changed to Done. You don’t need to browse the code to understand that.
Writing anywhere near this much boilerplate rule is extremely monotonous, particularly when postDelayed is set to a few days, particularly 50ms. There are much better and clearer expertise.
Washing All Emails onDestroy
Handler lessons has actually an appealing function removeCallbacksAndMessages – which can accept null as argument. It will pull all Runnables and emails published to a specific handler. Lets use it in onDestroy .
Lets run, rotate and dispose of memories.
Close! One instance.
This method was way better versus past one, since it keeps laws clear and readable. The actual only real cost is to remember to clear all messages on activity / fragment kill.
You will find an additional option which, if youre sluggish just like me, you will like much more. 🙂
Use WeakHandler
The Badoo group created the interesting notion of presenting WeakHandler – a category that acts as Handler , but is way better.
It requires advantageous asset of tough and weakened recommendations to eradicate mind leakages. I shall describe the idea at length quite afterwards, but lets look at the laws very first:
Very similar to the first signal besides one smaller huge difference as opposed to using android.os.Handler , Ive utilized WeakHandler . Lets run, rotate and dispose of storage:
Pleasant, is not it? The rule is cleaner than before, and storage are thoroughly clean nicely! 🙂
To utilize they, just include addiction towards build.gradle:
And transfer they within coffee lessons:
Check out Badoos github page, where you are able to fork they, or examine it’s supply rule
WeakHandler. How it works
The key aim of WeakHandler would be to hold Runnables / information hard-referenced while WeakHandler is hard-referenced. Once it may be GC-ed, all emails should go out aswell.
Is a simple diagram that displays differences when considering utilizing regular Handler and WeakHandler to publish private runnables:
Taking a look at the best diagram, task helps to keep a mention of the Handler , which content Runnable (leaves it into queue of information referenced from Thread). All things are fine except the secondary research from Runnable to Activity . While information is within the waiting line, all graphs cant end up being garbage-collected.
By comparison, into the bottom drawing task keeps WeakHandler , which keeps Handler inside the house. When we ask they to publish Runnable , it’s wrapped into WeakRunnable and uploaded. So that the Message waiting line keeps research simply to WeakRunnable . WeakRunnable keeps weak mention of the specified Runnable , therefore, the Runnable could be garbage-collected.
Another small secret is that WeakHandler nevertheless helps to keep a tough regard to the required Runnable , avoiding they from are garbage-collected while WeakRunnable was effective.
The side-effect of using WeakHandler usually all communications and runnables may possibly not be executed if WeakHandler happens to be garbage-collected. To stop that, only hold a reference to it from Activity. As soon as Activity is ready to getting built-up, all graphs with WeakHandler will compiled also.
Results
Using postDelayed in Android os needs extra efforts. To experience it we developed three various methods:
- Incorporate a fixed inner Runnable / Handler with WeakReference to owner course
- Clear all emails from Handler in onDestroy of Activity / Fragment
- Need WeakHandler from Badoo as a sterling silver bullet
it is your decision to select your favorite techniques. Another looks very reasonable, but demands some extra services. The 3rd is my favourite, demonstrably, it call for some attention too WeakHandler should not be employed without tough research from outdoors. And thank-you for reading!
