延迟初始化和保留周期

Question

在使用惰性初始化器时，是否有可能出现保留周期？

在blog post 和许多其他地方看到[unowned self]

class Person {

    var name: String

    lazy var personalizedGreeting: String = {
        [unowned self] in
        return "Hello, \(self.name)!"
        }()

    init(name: String) {
        self.name = name
    }
}

我试过了

class Person {

    var name: String

    lazy var personalizedGreeting: String = {
        //[unowned self] in
        return "Hello, \(self.name)!"
        }()

    init(name: String) {
        print("person init")
        self.name = name
    }

    deinit {
        print("person deinit")
    }
}

这样用过

//...
let person = Person(name: "name")
print(person.personalizedGreeting)
//..

发现“person deinit”被记录了。

所以似乎没有保留周期。 据我所知，当一个块捕获自我以及当这个块被自我强烈保留时，存在一个保留周期。这种情况看起来类似于保留循环，但实际上并非如此。

Answer 1

我试过这个[...]

lazy var personalizedGreeting: String = { return self.name }()

似乎没有保留周期

正确。

原因是立即应用的闭包{}() 被认为是@noescape。它不保留捕获的self。

供参考：Joe Groff's tweet。

Answer 2

在这种情况下，您不需要捕获列表，因为在 personalizedGreeting 实例化后没有引用 self。

正如 MartinR 在他的评论中所写，您可以通过在删除捕获列表时记录 Person 对象是否被取消初始化来轻松测试您的假设。

例如

class Person {
    var name: String

    lazy var personalizedGreeting: String = {
        _ in
        return "Hello, \(self.name)!"
        }()

    init(name: String) {
        self.name = name
    }

    deinit { print("deinitialized!") }
}

func foo() {
    let p = Person(name: "Foo")
    print(p.personalizedGreeting) // Hello Foo!
}

foo() // deinitialized!

显然在这种情况下不存在强引用循环的风险，因此在惰性闭包中不需要unowned self 的捕获列表。这样做的原因是惰性闭包只执行一次，并且只使用闭包的返回值来（惰性）实例化personalizedGreeting，而对self的引用没有，在在这种情况下，比闭包的执行时间更长。

但是，如果我们要在 Person 的类属性中存储类似的闭包，我们将创建一个强引用循环，因为 self 的属性将保持对 self 的强引用。例如：

class Person {
    var name: String

    var personalizedGreeting: (() -> String)?

    init(name: String) {
        self.name = name

        personalizedGreeting = {
            () -> String in return "Hello, \(self.name)!"
        }
    }

    deinit { print("deinitialized!") }
}

func foo() {
    let p = Person(name: "Foo")
}

foo() // ... nothing : strong reference cycle

---

假设：惰性实例化闭包默认自动将self 捕获为weak（或unowned）

当我们考虑下面的例子时，我们意识到这个假设是错误的。

/* Test 1: execute lazy instantiation closure */
class Bar {
    var foo: Foo? = nil
}

class Foo {
    let bar = Bar()
    lazy var dummy: String = {
        _ in
        print("executed")
        self.bar.foo = self 
            /* if self is captured as strong, the deinit
               will never be reached, given that this
               closure is executed */
        return "dummy"
    }()

    deinit { print("deinitialized!") }
}

func foo() {
    let f = Foo()
    // Test 1: execute closure
    print(f.dummy) // executed, dummy
}

foo() // ... nothing: strong reference cycle

即，foo() 中的 f 没有被取消初始化，鉴于这个强引用循环，我们可以得出结论，self 在惰性变量 dummy 的实例化闭包中被强烈捕获。

我们还可以看到，如果我们从不实例化 dummy，我们将永远不会创建强引用循环，这将支持最多一次惰性实例化闭包可以被视为运行时范围（很像 never达到如果) 是 a) 从未达到（未初始化）或 b) 达到、完全执行并“丢弃”（范围结束）。

/* Test 2: don't execute lazy instantiation closure */
class Bar {
    var foo: Foo? = nil
}

class Foo {
    let bar = Bar()
    lazy var dummy: String = {
        _ in
        print("executed")
        self.bar.foo = self
        return "dummy"
    }()

    deinit { print("deinitialized!") }
}

func foo() {
    let p = Foo()
    // Test 2: don't execute closure
    // print(p.dummy)
}

foo() // deinitialized!

---

有关强参考周期的更多信息，请参阅例如

• "Weak, strong, snowned, oh my!" - A guide to references in Swift