When self should be weakify?
How to diagnose retain cycle and when to use [weak self] to avoid retain cycle.
Introduction
Often we end up having a memory leak in the project. We know when our closure can increase retain count and when not. When I was executing function [Using self inside] in Notification Center Observer, I had an intuition that it won’t cause a retain cycle. As I was not calling NotificationCenter on self so I was pretty sure that it won’t cause a retain cycle but it did 😰.
How to diagnose retain cycle:
- Debug Memory Graph: To use debug memory graph, first you need to edit scheme.
![Enavle Malloc Scrabble and Malloc Stack [Live allocations only]](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*8L_ZM95k5f4-xmVwaYk5wQ.png)
# Malloc scribble will show you code in Show Memory Inspector when Debug Memory Graph is launched.
# You can tap on show only leaked blocks to see only leaked classes.
- Perform whatever app actions you want to analyse (the actions which can cause retain cycles).
# Open memory graph debugging mode by selecting this button.
- The memory graph debugger pauses app execution and shows the following:
- Or you can put breakpoint in
deinitto check class has been deinitialized or not.
Let’s take some use cases which can cause retain cycle:
Use Cases:
1. Assigning closure to closure:
While using any instance property or function inside closure, compile gives us the warning to use self.
Now, while using self we need to make sure that it should be weak else it will cause a retain cycle.
Note: lazy closure can also cause a retain cycle.
Why will it cause retain cycle: Because closure captures variables which will end up in increasing retain count. If we don’t use self` inside closure then there is no retain cycle.
Link for closure without self: https://gist.github.com/aainaj/1544b9047a94b0e0015803808d58f3fc
2. Assigning function to closure:
On assigning function to closure, we assign function pointer so it actually. Function pointer is defined as: ListViewController.makeList(self). It results in a retain cycle always. So it’s good to always assign [weak self] to closure.
Retain cycle can be avoided by using [weak self]
3. DispatchQueue:
Invoking closure in DispatchQueue doesn’t create a retain cycle as we are not calling this function on self`. It’s safe to use below code:
4. Async DispatchQueue:
In the previous example, We just changed the text color of a label so we may think that it won’t cause a retain cycle. But what if we are doing async API calls in dispatch queue. In this case, it doesn’t retain self but finishes all tasks submitted to the queue and then deallocate class. When a view is going off-screen, we can cancel tasks so that they don’t get executed when class is not in the hierarchy.
5. NotificationCenter:
As we don’t call notification center on self so it shouldn’t cause a retain cycle. But NotificationCenter.addObserver document says it copies our block so [weak self] should be used.
6. UIView.animate:
It’s not called on self so using self inside animations block doesn’t cause a retain cycle.
Reward:
