It will help us with quite a few low-level dilemmas like memory administration, platform type dependencies, an such like.

But we however often bring accidents with OutOfMemory. Therefore wheres the garbage collector?

Im probably target one of many cases where big objects in storage cant be cleared for an extended period. This example is not ultimately a memory drip items is going to be collected eventually therefore we sometimes dismiss it. That isn’t better as it can occasionally result in OOM problems.

The actual situation Im describing may be the Handler problem, and is typically found as a caution by Lint.

Fundamental Sample

This is exactly an extremely fundamental task. Notice that this private Runnable happens to be submitted toward Handler with a long delay. Well manage it and turn the telephone few times, after that dump memories and analyze they.

We’ve seven recreation in storage today. This might be not really great. Lets figure out precisely why GC struggles to remove them.

The query we made to bring a list of all strategies remaining in memories was developed in OQL (item Query code), and that is very simple, but strong.

As you care able to see, one of many strategies are referenced by this$0 . It is an indirect research from the private class into the holder lessons. This$0 are referenced by callback , which will be subsequently referenced by a chain of subsequent s of content returning to an important thread.

When you produce a non-static course inside the owner lessons, Java brings an indirect regard to the owner

When you upload Runnable or Message into Handler , it is next kept in list of content commands referenced from LooperThread up until the message are executed. Posting postponed information is actually a clear drip for at least the amount of time regarding the delay appreciate. Publishing immediately may cause a short-term drip nicely in the event the queue of information are large.

Static Runnable Option

Lets make an effort to conquer a storage drip by getting rid of this$0 , by transforming the anonymous class to static.

Run, rotate to get the memory space dump.

What, once again? Lets read exactly who helps to keep referring to recreation .

Read the base of the forest task try held as a mention of mContext inside mTextView of one’s DoneRunnable lessons. Utilizing fixed interior tuition is certainly not adequate to overcome mind leaks, nevertheless. We have to create a lot more.

Static Runnable With WeakReference

Lets keep using iterative fixes and get rid of the mention asian date reviews of the TextView, which will keep activity from are damaged.

Note that we have been maintaining WeakReference to TextView, and lets work, rotate and dispose of mind.

Be cautious with WeakReferences. They can be null at any minute, thus solve all of them 1st to a regional varying (difficult reference) following examine to null before utilize.

Hooray! Singular activity case. This solves all of our memory space difficulties.

Very because of this strategy we have to:

• Use static interior classes (or outer sessions)
• Use WeakReference to all or any stuff manipulated from Handler / Runnable

If you examine this rule on the original laws, you will probably find an impact in readability and rule clearance. The initial rule is a lot smaller and much clearer, and youll see that in the course of time, text in textView are altered to Done. You don’t need to look at signal to realise that.

Composing anywhere near this much boilerplate rule is extremely tiresome, particularly when postDelayed is set to a short time, like 50ms. You’ll find best and crisper solutions.

Cleanup All Emails onDestroy

Handler class provides a fascinating element removeCallbacksAndMessages – which could take null as discussion. It is going to eliminate all Runnables and Messages published to a particular handler. Lets use it in onDestroy .

Lets run, rotate and dispose of memory.

Good! Singular instance.

This process are way better as compared to previous one, whilst keeps code obvious and understandable. The only overhead should take the time to clean all communications on task / fragment destroy.

You will find an additional remedy which, if youre lazy like me, you might like much more. 🙂

Need WeakHandler

The Badoo employees came up with the fascinating concept of adding WeakHandler – a class that behaves as Handler , it is means less dangerous.

It will require benefit of difficult and weak sources relieve mind leaks. I am going to describe the concept thoroughly quite after, but lets check out the signal 1st:

Much like the first rule in addition to one lightweight distinction instead of utilizing android.os.Handler , Ive used WeakHandler . Lets operate, rotate and dump memory:

Kind, is not they? The signal is actually cleaner than in the past, and storage try thoroughly clean besides! 🙂

To make use of it, merely add dependency to your build.gradle:

And import they inside java lessons:

Check out Badoos github page, where you can fork it, or learning it’s origin laws

WeakHandler. The way it works

The main aim of WeakHandler will be hold Runnables / information hard-referenced while WeakHandler can hard-referenced. Once it could be GC-ed, all emails should go away nicely.

Let me reveal an easy diagram that displays differences between using regular Handler and WeakHandler to publish private runnables:

Studying the top diagram, Activity keeps a mention of the Handler , which content Runnable (throws they into waiting line of information referenced from bond). Everything is fine except the indirect research from Runnable to task . While content is within the waiting line, all graphs cant become garbage-collected.

By comparison, in the bottom diagram task retains WeakHandler , which will keep Handler around. Whenever we query they to publish Runnable , truly wrapped into WeakRunnable and posted. So that the content waiting line helps to keep research merely to WeakRunnable . WeakRunnable keeps poor reference to the specified Runnable , and so the Runnable may be garbage-collected.

Another little secret is the fact that WeakHandler nevertheless keeps a tough mention of the required Runnable , avoiding they from being garbage-collected while WeakRunnable try active.

The side-effect of utilizing WeakHandler is the fact that all messages and runnables may possibly not be executed if WeakHandler has become garbage-collected. To stop that, only hold a reference to it from task. As soon as task is able to getting collected, all graphs with WeakHandler will gathered as well.

Conclusions

Making use of postDelayed in Android need further effort. To get they we developed three different methods:

• Incorporate a static interior Runnable / Handler with WeakReference to owner course
• Evident all information from Handler in onDestroy of task / Fragment
• Utilize WeakHandler from Badoo as a silver round

it is your responsibility to choose your favorite technique. Another looks affordable, but needs some extra jobs. The 3rd try my personal preferred, certainly, it call for some focus aswell WeakHandler should not be utilised without difficult reference from external. And thank you so much for researching!