美文网首页
Swift5.1—闭包的循环强引用

Swift5.1—闭包的循环强引用

作者: anny_4243 | 来源:发表于2020-07-09 10:07 被阅读0次

    前面我们看到了循环强引用是在两个类实例属性互相保持对方的强引用时产生的,还知道了如何用弱引用和无主引用来打破这些循环强引用。

    循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性,并且这个闭包体中又使用了这个类实例时。这个闭包体中可能访问了实例的某个属性,例如 self.someProperty,或者闭包中调用了实例的某个方法,例如 self.someMethod()。这两种情况都导致了闭包“捕获”self,从而产生了循环强引用。

    循环强引用的产生,是因为闭包和类相似,都是引用类型。当你把一个闭包赋值给某个属性时,你是将这个闭包的引用赋值给了属性。实质上,这跟之前的问题是一样的——两个强引用让彼此一直有效。但是,和两个类实例不同,这次一个是类实例,另一个是闭包。

    Swift 提供了一种优雅的方法来解决这个问题,称之为 闭包捕获列表(closure capture list)。同样的,在学习如何用闭包捕获列表打破循环强引用之前,先来了解一下这里的循环强引用是如何产生的,这对我们很有帮助。

    下面的例子为你展示了当一个闭包引用了 self 后是如何产生一个循环强引用的。例子中定义了一个叫 HTMLElement 的类,用一种简单的模型表示 HTML 文档中的一个单独的元素:

    class HTMLElement {
    
        let name: String
        let text: String?
    
        lazy var asHTML: () -> String = {
            if let text = self.text {
                return "<\(self.name)>\(text)</\(self.name)>"
            } else {
                return "<\(self.name) />"
            }
        }
    
        init(name: String, text: String? = nil) {
            self.name = name
            self.text = text
        }
    
        deinit {
            print("\(name) is being deinitialized")
        }
    
    }
    

    HTMLElement 类定义了一个 name 属性来表示这个元素的名称,例如代表头部元素的 "h1",代表段落的 "p",或者代表换行的 "br"HTMLElement 还定义了一个可选属性 text,用来设置 HTML 元素呈现的文本。

    除了上面的两个属性,HTMLElement 还定义了一个 lazy 属性 asHTML。这个属性引用了一个将 nametext 组合成 HTML 字符串片段的闭包。该属性是 Void -> String 类型,或者可以理解为“一个没有参数,返回 String 的函数”。

    默认情况下,闭包赋值给了 asHTML 属性,这个闭包返回一个代表 HTML 标签的字符串。如果 text 值存在,该标签就包含可选值 text;如果 text 不存在,该标签就不包含文本。对于段落元素,根据 text"some text" 还是 nil,闭包会返回 "<p>some text</p>" 或者 "<p />"

    可以像实例方法那样去命名、使用 asHTML 属性。然而,由于 asHTML 是闭包而不是实例方法,如果你想改变特定 HTML 元素的处理方式的话,可以用自定义的闭包来取代默认值。

    例如,可以将一个闭包赋值给 asHTML 属性,这个闭包能在 text 属性是 nil 时使用默认文本,这是为了避免返回一个空的 HTML 标签:

    let heading = HTMLElement(name: "h1")
    let defaultText = "some default text"
    heading.asHTML = {
        return "<\(heading.name)>\(heading.text ?? defaultText)</\(heading.name)>"
    }
    print(heading.asHTML())
    // 打印“<h1>some default text</h1>”
    

    注意

    asHTML 声明为 lazy 属性,因为只有当元素确实需要被处理为 HTML 输出的字符串时,才需要使用 asHTML。也就是说,在默认的闭包中可以使用 self,因为只有当初始化完成以及 self 确实存在后,才能访问 lazy 属性。

    HTMLElement 类只提供了一个构造器,通过 nametext(如果有的话)参数来初始化一个新元素。该类也定义了一个析构器,当 HTMLElement 实例被销毁时,打印一条消息。

    下面的代码展示了如何用 HTMLElement 类创建实例并打印消息:

    var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
    print(paragraph!.asHTML())
    // 打印“<p>hello, world</p>”
    

    注意

    上面的 paragraph 变量定义为可选类型的 HTMLElement,因此我们可以赋值 nil 给它来演示循环强引用。

    不幸的是,上面写的 HTMLElement 类产生了类实例和作为 asHTML 默认值的闭包之间的循环强引用。循环强引用如下图所示:

    实例的 asHTML 属性持有闭包的强引用。但是,闭包在其闭包体内使用了 self(引用了 self.nameself.text),因此闭包捕获了 self,这意味着闭包又反过来持有了 HTMLElement 实例的强引用。这样两个对象就产生了循环强引用。(更多关于闭包捕获值的信息,请参考 值捕获)。

    注意

    虽然闭包多次使用了 self,它只捕获 HTMLElement 实例的一个强引用。

    如果设置 paragraph 变量为 nil,打破它持有的 HTMLElement 实例的强引用,HTMLElement 实例和它的闭包都不会被销毁,也是因为循环强引用:

    paragraph = nil
    

    注意,HTMLElement 的析构器中的消息并没有被打印,证明了 HTMLElement 实例并没有被销毁。

    解决闭包的循环强引用

    在定义闭包时同时定义捕获列表作为闭包的一部分,通过这种方式可以解决闭包和类实例之间的循环强引用。捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样,声明每个捕获的引用为弱引用或无主引用,而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。

    注意

    Swift 有如下要求:只要在闭包内使用 self 的成员,就要用 self.someProperty 或者 self.someMethod()(而不只是 somePropertysomeMethod())。这提醒你可能会一不小心就捕获了 self

    定义捕获列表

    捕获列表中的每一项都由一对元素组成,一个元素是 weakunowned 关键字,另一个元素是类实例的引用(例如 self)或初始化过的变量(如 delegate = self.delegate)。这些项在方括号中用逗号分开。

    如果闭包有参数列表和返回类型,把捕获列表放在它们前面:

    lazy var someClosure = {
        [unowned self, weak delegate = self.delegate]
        (index: Int, stringToProcess: String) -> String in
        // 这里是闭包的函数体
    }
    

    如果闭包没有指明参数列表或者返回类型,它们会通过上下文推断,那么可以把捕获列表和关键字 in 放在闭包最开始的地方:

    lazy var someClosure = {
        [unowned self, weak delegate = self.delegate] in
        // 这里是闭包的函数体
    }
    

    弱引用和无主引用

    在闭包和捕获的实例总是互相引用并且总是同时销毁时,将闭包内的捕获定义为 无主引用

    相反的,在被捕获的引用可能会变为 nil 时,将闭包内的捕获定义为 弱引用。弱引用总是可选类型,并且当引用的实例被销毁后,弱引用的值会自动置为 nil。这使我们可以在闭包体内检查它们是否存在。

    注意

    如果被捕获的引用绝对不会变为 nil,应该用无主引用,而不是弱引用。

    前面的 HTMLElement 例子中,无主引用是正确的解决循环强引用的方法。这样编写 HTMLElement 类来避免循环强引用:

    class HTMLElement {
    
        let name: String
        let text: String?
    
        lazy var asHTML: () -> String = {
            [unowned self] in
            if let text = self.text {
                return "<\(self.name)>\(text)</\(self.name)>"
            } else {
                return "<\(self.name) />"
            }
        }
    
        init(name: String, text: String? = nil) {
            self.name = name
            self.text = text
        }
    
        deinit {
            print("\(name) is being deinitialized")
        }
    
    }
    

    上面的 HTMLElement 实现和之前的实现一致,除了在 asHTML 闭包中多了一个捕获列表。这里,捕获列表是 [unowned self],表示“将 self 捕获为无主引用而不是强引用”。

    和之前一样,我们可以创建并打印 HTMLElement 实例:

    var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
    print(paragraph!.asHTML())
    // 打印“<p>hello, world</p>”
    

    使用捕获列表后引用关系如下图所示:

    这一次,闭包以无主引用的形式捕获 self,并不会持有 HTMLElement 实例的强引用。如果将 paragraph 赋值为 nilHTMLElement 实例将会被销毁,并能看到它的析构器打印出的消息:

    paragraph = nil
    // 打印“p is being deinitialized”
    

    相关文章

      网友评论

          本文标题:Swift5.1—闭包的循环强引用

          本文链接:https://www.haomeiwen.com/subject/byaccktx.html