Swift - Expecting a leak after strongly capturing self in closure

Question

Can anyone please explain why this doesn't leak?

I'm capturing self within a closure so I would have two strong pointers pointing at each other, therefore, the deinit message shouldn't ever be called for the Person object.

First, this is my class Person:

class Person {
    var name: String
    init(name: String) { self.name = name }
    deinit { print("\(name) is being deinitialized") }
}

And this is my ViewController's implementation:

class ViewController: UIViewController {

    var john:Person?

    func callClosureFunction( closure:(name:Bool) -> () ) {
        closure(name: true)
    }

    override func viewDidLoad() {
        super.viewDidLoad()

        john = Person(name:"John")

        self.callClosureFunction { (name) in

            self.john?.name = "John Appleseed"
            self.john = nil

            // xcode prints - John Appleseed is being deinitialized
        }

    }

}

I was expecting to be able to fix the issue by doing:

self.callClosureFunction { [weak self] (name) in ...

But that wasn't even necessary. Why?

Daniel Hall · Accepted Answer · 2016-08-10T19:16:13.073

Since your view controller is not retaining the closure, there is no circular reference. If you wrote this:

class ViewController: UIViewController {

    var john:Person?
    var closure:(Bool)->()? 

    func callClosureFunction( closure:((name:Bool) -> ())? ) {
        closure?(name: true)
    }

    override func viewDidLoad() {
        super.viewDidLoad()

        john = Person(name:"John")
        closure = { (name) in

            self.john?.name = "John Appleseed"    

            // Because this closure will never be released, the instance of Person will never deinit either
        }
        self.callClosureFunction(closure) 
    }  
}

then the view controller would retain the closure and the closure would retain the view controller via its reference to self. Therefore, neither would be released, and if you don't explicitly set self.john = nil (which you did in your original example), then the Person instance would never get deninit called.

It's quite common to inappropriately use weak self in closures when not necessary (and this can actually lead to some obscure bugs). The key rule to remember is that weak references are not the default in general under ARC. Strong should be the default unless it would lead to a retain cycle, in which case weak should be used only to break that circular reference. Same for closures: strong self should be the default, unless the self in this case also has a strong reference to the closure itself.

the `John Appleseed` `Person` object will still deinit. See my answer — Alexander, Aug 10 '16 at 16:26
@AlexanderMomchliov If the closure retains the VC (self) and the VC retains the closure as in my example, then the VC never gets released (nor does the closure). If the VC never deinits, then it never in turn releases its reference to the Person object, which means that the Person object would never deinit either. — Daniel Hall, Aug 10 '16 at 18:42
Doesn't matter if there's a retain cycle. `john` is explicitly set to `nil`, removing the last reference, thus causing ARC to `deinit` it. — Alexander, Aug 10 '16 at 18:54
@AlexanderMomchliov Oh right — good point that I missed. Updated my answer to reflect this. Thanks! — Daniel Hall, Aug 10 '16 at 19:13

ff10 · Answer 2 · 2016-08-10T16:02:56.110

0

You're capturing self which points to ViewController, but you're wondering about the Person instance.

Person is actually not circular referenced and therefore gets de-initalized and released just fine when you set it to nil at the end of your closure.

Implement deinit for ViewController and see how that works.

edited Aug 10 '16 at 16:02

answered Aug 10 '16 at 15:33

ff10

3,046
1
32
55

score 0 · Answer 3 · answered Aug 10 '16 at 16:20

I'm capturing self within a closure so I would have two strong pointers pointing at each other, therefore, the deinit message shouldn't ever be called for the Person object.

No, you have one strong pointer, from the closure to self. There's no cyclic reference back from the closure to self. Thus, you have a directed acylic graph, which is no problem for ARC.

However, your experiment is flawed, from the get-go. Even if the closure was captured, the John Appleseed Person object would still deinit. This object's lifecycle is exclusively dependent on on the john reference from your ViewController. When you set that reference to nil, you're removing the last reference to the John Appleseed object, thus it's deinitialized.

Swift - Expecting a leak after strongly capturing self in closure

3 Answers3