Swift中文教程（十六） 自动引用计数

number73 ＝ nil

class Customer {  
    let name: String  
    var card: CreditCard?  
    init(name: String) {  
        self.name = name  
    }  
    deinit { println("(name) is being deinitialized") }  
}  
class CreditCard {  
    let number: Int  
    unowned let customer: Customer  
    init(number: Int, customer: Customer) {  
        self.number = number  
        self.customer = customer  
    }  
    deinit { println("Card #(number) is being deinitialized") }  
}

    class Customer {  
        let name: String  
        var card: CreditCard?  
        init(name: String) {  
            self.name = name  
        }  
        deinit { println("(name) is being deinitialized") }  
    }  
    class CreditCard {  
        let number: Int  
        unowned let customer: Customer  
        init(number: Int, customer: Customer) {  
            self.number = number  
            self.customer = customer  
        }  
        deinit { println("Card #(number) is being deinitialized") }  
    }

下面的代码段定义了Customer类型可选变量john，用来存储一个特定用户的引用，这个变量初值为nil：

Java代码

var john: Customer?

 

现在可以创建一个Customer实例，并初始化一个新的CreditCard实例来设置customer实例的card属性：

Java代码

    john = Customer(name: "John Appleseed")  
    john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)

 

下图是引用间的连接管理：

 

Customer实例有一个到CreditCard实例的强引用，CreaditCard实例有一个到Customer实例无主引用。

 

因为无主引用的存在，当你破坏变量john持有的强引用时，就再也没有到Customer实例的强引用了。

 

 

因为没有到Customer实例的强引用，实例被释放了。之后，到CreditCard实例的强引用也不存在了，因此这个实例也被释放了：

Java代码

john = nil  
// prints "John Appleseed is being deinitialized"  
// prints "Card #1234567890123456 is being deinitialized"

 

上面的代码段显示了变量john设置为nil后Customer实例和CreditCard实例被析构的信息。

 

无主引用和隐式拆箱可选属性
上面的弱引用和无主引用例子是更多常见场景中的两个，表面打破强引用循环是必要的。

 

例子Person和Apartment显示了当互相引用的两个属性被设置为nil时可能造成强引用循环。这种情况可以使用弱引用来解决。

 

例子Customer和CreditCard显示了一个属性可以设置为nil，而另一个不可以为nil时可能造成的强引用循环。这种情况可以使用无主引用解决。

 

但是，有第三种情况，两个属性都一直有值，并且都不可以被设置为nil。这种情况下，通常联合一个类种的无主属性和一个类种的隐式装箱可选属性（implicitly unwrapped optional property)。

 

这保证了两个属性都可以被直接访问，并且防止了引用循环。这一节展示了如何进行这样的设置。

 

下面的例子定义了两个类，Coutry和City，两者的属性都存放另外一个类的实例。在数据模型中，每个国家都有一个首都，而每个城市都属于一个国家。代码如下：

Java代码

    class Country {  
        let name: String  
        let capitalCity: City!  
        init(name: String, capitalName: String) {  
            self.name = name  
            self.capitalCity = City(name: capitalName, country: self)  
        }  
    }  
    class City {  
        let name: String  
        unowned let country: Country  
        init(name: String, country: Country) {  
            self.name = name  
            self.country = country  
        }  
    }

 

为表达这样的关系，City的构造器有一个参数为Country实例，并将他存为country属性。

 

City的构造器也在Country的构造器中被调用。但是直到一个新的Country实例被完整地初始化，Country构造器不能传递self给City的构造器（在两阶段初始化“Two-Phase Initialization”节描述）

 

为处理这样的情况，声明Country的属性capitalCity属性为隐式拆箱可选属性，通过在类型注解后加检测符号实现（City！）。这表 明capitalCity属性像其他可选属性一样有一个默认值nil，但是可以不需要对值拆箱就可以访问（隐式拆箱选项（implicitly unwrapped optionals）描述）

 

因为capitalCity有一个默认值nil，所以当在Country的构造器中设置了name属性的值后，一个新的Country实例就完全地被初始化了，这表明Country构造器已经可以传递隐式self属性，从而设置capitalCity属性值。

 

这表明你可以在一个单独的语句中创建Country和CIty实例，不会造成强引用循环，并且可以不用使用检测符号（！）解包可选值来直接访问capitalCity属性：

Java代码

var country = Country(name: "Canada", capitalName: "Ottawa")  
println("(country.name)'s capital city is called (country.capitalCity.name)")  
// prints "Canada's capital city is called Ottawa"

 

上面的例子中，隐式解包选项的使用表示分阶段初始化是可行的。当初始化完成时，capitalCity属性可以像一个非可选值那样访问，并且不会造成强引用循环。

 

5、闭包的强引用循环

 

前面你知道了当两个类实例持有对方的强引用时强引用循环是怎样被创建的。你也知道了怎样使用弱引用和无主引用来破坏强引用循环。

 

当将一个闭包赋值给一个类实例的属性，并且闭包体捕获这个实例时，也可能存在一个强引用循环。捕获实例是因为闭包体访问了实例的属性，就像 self.someProperty，或者调用了实例的方法，就像self.someMethod（）。不管哪种情况，这都造成闭包捕获self，造成强 引用循环。

 

这个强引用循环的存在是因为闭包和类一样都是引用类型。当你将闭包赋值给属性时，就给这个闭包赋值了一个引用。本质上和前面的问题相同－两个强引用都互相地指向对方。但是，与两个类实例不同，这里是一个类与一个闭包。

 

Swift为这个问题提供了一个优美的解决方法，就是闭包捕获列表。但是，在学习怎样通过闭包捕获列表破坏强引用循环以前，有必要了解这样的循环是怎样造成的。

 

下面的例子展示了当使用闭包引用self时强引用循环是怎样造成当。定义了一个名为HTMLElement的类，建模了HTML文档中的一个单独的元素：

Java代码

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

 

这个HTMLElement类定义了一个表示元素（例如“p“，”br“）名称的属性name，和一个可选属性text，表示要在页面上渲染的html元素的字符串的值

 

另外，还定义了一个懒惰属性asHTML。这个属性引用一个闭包，这个闭包结合name与text形成一个html代码字符串。这个属性类型是（）－> String，表示一个函数不需要任何参数，返回一个字符串值。

 

默认地，asHTML属性赋值为返回HTML标签字符串的闭包。这个标签包含了可选的text值。对一个段落而言，闭包返 回”<p>some text</p>”或者”<p />”，取决其中的text属性为“some text”还是nil。

 

asHTML属性的命名和使用都和实例方法类似，但是，因为它是一个闭包属性，如果想渲染特定的html元素，你可以使用另外一个闭包来代替asHTML属性的默认值。

 

这个HTMLElement类提供单一的构造器，传递一个name和一个text参数。定义了一个析构器，打印HTMLElement实例的析构信息。

 

下面是如何使用HTMLElement类来创建和打印一个新的实例：

Java代码

    var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")  
    println(paragraph!.asHTML())  
    // prints "hello, world"

 

不幸的是，上面所写的HTMLElemnt类的实现会在HTMLElement实例和闭包所使用的默认asHTML值之间造成强引用循环，下面是其图示：

 

实例的asHTML属性持有其闭包的一个强引用，但是因为闭包在其类内引用self（self.name和self.text方式），闭包捕获类本 身，意味着它也持有到HTMLElement实例的引用。强引用循环就这样建立了。（关于闭包捕获值的更多信息，参见CapturingValues）

 

如果设置paragraph变量值为nil，破坏了到HTMLElement实例的强引用，实例和其闭包都不会被析构，因为强引用循环：

Java代码

paragraph ＝ nil

 

注意HTMLElement析构器中的提示信息不会被打印，表示HTMLElement实例并没有被析构。

 

6、解决闭包的强引用循环
通过定义捕获列表为闭包的一部分可以解决闭包和类实例之间的强引用循环。捕获列表定义了在闭包体内何时捕获一个或多个引用类型的规则。像解决两个类实例之间的强引用循环一样，你声明每个捕获引用为弱引用或者无主引用。究竟选择哪种定义取决于代码中其他部分间的关系

 

定义捕获列表
捕获列表中的每个元素由一对weak／unowned关键字和类实例（self或someInstance）的引用所组成。这些对由方括号括起来并由都好分隔。

 

将捕获列表放在闭包参数列表和返回类型（如果提供）的前面：

Java代码

@lazy var someClosure: (Int, String) -> String = {  
    [unowned self] (index: Int, stringToProcess: String) -> String in  
    // closure body goes here  
}

 

如果闭包没有包含参数列表和返回值，它们可以从上下文中推断出来的话，将捕获列表放在闭包的前面，后面跟着关键字in：

Java代码

@lazy var someClosure: () -> String = {  
    [unowned self] in  
    // closure body goes here  
}

 

弱引用和无主引用
当闭包和实例之间总是引用对方并且同时释放时，定义闭包捕获列表为无主引用。
当捕获引用可能为nil，定义捕获列表为弱引用。弱引用通常是可选类型，并且在实例释放后被设置为nil。这使得你可以在闭包体内检查实例是否存在。

 

在例子HTMLElement中，可以使用无主引用来解决强引用循环问题，下面是其代码：

Java代码

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

 

这个HTMLELement实现在之前的基础上在asHTML闭包中加上了捕获列表。这里，捕获列表是[unowned self]，表示作为无主引用来捕获自己而不是强引用。

 

你可以像之间一样创建和打印HTMLElement实例：

Java代码

var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")  
println(paragraph!.asHTML())  
// prints "hello, world"

 

下图是使用捕获列表后的引用图示：

 

此时，闭包捕获自身是一个无主引用，并不持有捕获HTMLelement实例的强引用。如果你设置paragraph的强引用为nil，HTMLElement实例就被释放了，可以从析构信息中看出来：

Java代码

paragraph = nil  
// prints "p is being deinitialized"

感谢翻译小组成员：李起攀(微博)、若晨(微博)、YAO、粽子、山有木兮木有枝、渺-Bessie、墨离、矮人王、约书亚、CXH、Tiger大顾(微博)
原始链接http://letsswift.com/2014/06/automatic-reference-counting