自动引用计数

本章十分重要，文档原文配有大量的图解，具体请查阅官方文档。

Swift使用自动引用计数（ARC）机制来跟踪和管理你的应用程序的内存。通常情况下，Swift内存管理机制会一直起作用，你无须自己来考虑内存的管理。ARC会在类的实例不再被使用时，自动释放其占用的内存。

然而在少数情况下，为了能帮助你管理内存，ARC需要更多的，代码之间关系的信息。本章描述了这些情况，并且为你示范怎样才能使ARC来管理你的应用程序的所有内存。

注意，引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。

自动引用计数的工作机制

当你每次创建一个类的新的实例的时候，ARC会分配一块内存来储存该实例信息。内存中会包含实例的类型信息，以及这个实例所有相关的存储型属性的值。

此外，当实例不再被使用时，ARC释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。

然而，当ARC收回和释放了正在被使用中的实例，该实例的属性和方法将不能再被访问和调用。实际上，如果你试图访问这个实例，你的应用程序很可能会崩溃。

为了确保使用中的实例不会被销毁，ARC会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为1，ARC都不会销毁这个实例。

为了使上述成为可能，无论你将实例赋值给属性、常量或变量，它们都会创建此实例的强引用。之所以称之为“强”引用，是因为它会将实例牢牢地保持住，只要强引用还在，实例是不允许被销毁的。

自动引用计数实践

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("Person.init(name:) called")
    }
    deinit {
        print("Person.deinit called")
    }
}

var p1: Person?     // nil
var p2: Person?     // nil
var p3: Person?     // nil
p1 = Person(name: "Tim")    // Person.init(name:) called，建立了一个强引用，只打印一次，表示仅仅创建了一个Person实例但是有三个引用变量
p2 = p1     // 又建立了一个强引用
p3 = p1     // 建立了一个强引用

p1 = nil    // 断开一个强引用
p2 = nil    // 断开一个强引用

p3 = nil    // Person.deinit called，断开一个强引用，此时才打印，才执行Person实例的析构器

类实例之间的循环强引用

在上面的例子中，ARC会跟踪你所新创建的Person实例的引用数量，并且会在Person实例不再被需要时销毁它。

然而，我们可能会写出一个类实例的强引用数永远不能变成0的代码。如果两个类实例互相持有对方的强引用，因而每个实例都让对方一直存在，这就是所谓的循环强引用。

可以通过定义类之间的关系为弱引用或无主引用，以替代强引用，从而解决循环强引用的问题。

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?   // apartment属性是可选的，因为一个人并不总是拥有公寓。
    deinit { print("Person.deinit called") }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    var tenant: Person?     // tenant属性是可选的，因为一栋公寓并不总是有居民。
    deinit { print("Apartment.deinit called") }
}

var p: Person?      // nil
var a: Apartment?   // nil

p = Person(name: "Tim")
a = Apartment(unit: "A6666")

p!.apartment = a
a!.tenant = p

p = nil
a = nil     // 依然没有执行析构器，应用程序中造成了内存泄漏！！！

解决实例之间的循环强引用

Swift提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题：弱引用（weak reference）和无主引用（unowned reference）。

弱引用和无主引用允许循环引用中的一个实例引用另外一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用。

对于生命周期中会变为nil的实例使用弱引用。相反地，对于初始化赋值后再也不会被赋值为nil的实例，使用无主引用。

弱引用

弱引用不会对其引用的实例保持强引用，因而不会阻止ARC销毁被引用的实例。这个特性阻止了引用变为循环强引用。声明属性或者变量时，在前面加上weak关键字表明这是一个弱引用。

在实例的生命周期中，如果某些时候引用没有值（nil，实际情况下，我们可以把引用置为nil的时候使用弱引用^_^），那么使用弱引用可以避免循环强引用。如果引用总是有值，则可以使用无主引用。在上面Apartment的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。

注意，弱引用必须被声明为变量，表明其值能在运行时被修改。弱引用不能被声明为常量。
因为弱引用可以没有值，必须将每一个弱引用声明为可选类型。在Swift中，推荐使用可选类型描述可能没有值的类型。

因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC会在引用的实例被销毁后自动将其赋值为nil！！！因此可以像其他可选值一样，检查弱引用的值是否存在，你将永远不会访问已销毁的实例的引用。

在使用垃圾收集的系统里，弱指针有时用来实现简单的缓冲机制，因为没有强引用的对象只会在内存压力触发垃圾收集时才被销毁。但是在ARC中，一旦值的最后一个强引用被移除，就会被立即销毁，这导致弱引用并不适合上面的用途。

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("Person.deinit called") }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    weak var tenant: Person?
    deinit { print("Apartment.deinit called") }
}

var p: Person?      // nil
var a: Apartment?   // nil

p = Person(name: "Tim")
a = Apartment(unit: "A6666")

p!.apartment = a
a!.tenant = p

p = nil         // Person.deinit called立即打印
a = nil         // Apartment.deinit called也打印了

无主引用

和弱引用类似，无主引用不会牢牢保持住引用的实例。和弱引用不同的是，无主引用是永远有值的。因此，无主引用总是被定义为非可选类型（non-optional type）。你可以在声明属性或者变量时，在前面加上关键字unowned表示这是一个无主引用。

由于无主引用是非可选类型，你不需要在使用它的时候将它展开。无主引用总是可以被直接访问。不过ARC无法在实例被销毁后将无主引用设为nil，因为非可选类型的变量不允许被赋值为nil。

注意，如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。使用无主引用，你必须确保引用始终指向一个未销毁的实例。还需要注意的是如果你试图访问实例已经被销毁的无主引用，Swift确保程序会直接崩溃，而不会发生无法预期的行为。所以你应当避免这样的事情发生。

/** * 在这个数据模型中，模拟了银行客户和客户的信用卡。一个客户可能有或者没有信用卡，但是一张信用卡总是关联着一个客户。 */
class Customer {
    let name: String
    var card: CreditCard?   // 一个客户可能有或者没有信用卡，强引用！此处要是也声明为weak，由于下面创建的是CreditCard匿名实例，没有强引用引用它，所以CreditCard匿名实例刚创建完就析构了！所以看起来，没有对应的同时使用weak和unowned的情况吧
    init(name: String) { self.name = name }
    deinit { print("Customer.deinit called") }
}

class CreditCard {
    let number: UInt64  // number属性被定义为UInt64类型而不是Int类型，以确保number属性的存储量在32位和64位系统上都能足够容纳 16 位的卡号。
    unowned let customer: Customer  // 一张信用卡总是关联着一个客户，将customer属性定义为无主引用，用以避免循环强引用
    init(number: UInt64,customer: Customer) {      // 只能通过将一个number值和customer实例传递给CreditCard构造函数的方式来创建CreditCard实例。这样可以确保当创建CreditCard实例时总是有一个customer实例与之关联。
        self.number = number
        self.customer = customer
    }
    deinit { print("CreditCard.deinit called") }
}

var c: Customer?   // nil
c = Customer(name: "Tim")
c!.card = CreditCard(number: 1234_5678_9012_3456,customer: c!)
c = nil
/* 下面两个同时立即打印了 Customer.deinit called CreditCard.deinit called */

无主引用以及隐式解析可选属性

上面弱引用和无主引用的例子涵盖了两种常用的需要打破循环强引用的场景。

• Person和Apartment的例子展示了两个属性的值都允许为nil，并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。
• Customer和CreditCard的例子展示了一个属性的值允许为nil，而另一个属性的值不允许为nil，这也可能会产生循环强引用。这种场景最适合通过无主引用来解决。

然而，存在着第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后永远不会为nil。在这种场景中，需要一个类使用无主属性，而另外一个类使用隐式解析可选属性。

这使两个属性在初始化完成后能被直接访问（不需要可选展开），同时避免了循环引用。

class Country {
    let name: String
    var capitalCity: City!  // 每个国家必须有首都，根据前面介绍的，由于capitalCity是变量，此时以及初始化为nil了。若是常量则没有。
    init(name: String,capitalName: String) {
        self.name = name
        self.capitalCity = City(name: name,country: self)
        print("Country.init(name:capitalName:) called")
    }
    deinit { print("Country.deinit called") }
}

class City {
    let name: String
    unowned let country: Country    // 每个城市必须属于一个国家
    init(name: String,country: Country) {
        self.name = name
        self.country = country
        print("City.init(name:country:) called")
    }
    deinit { print("City.deinit called") }
}

var country = Country(name: "China",capitalName: "Beijing")
/* 并没有调用析构 City.init(name:country:) called Country.init(name:capitalName:) called */
print("==========")



class A {
    static func fun() {
        var country = Country(name: "China",capitalName: "Beijing")
    }
}
A.fun()     // 函数退出时，两个实例都被析构了！
/* City.init(name:country:) called Country.init(name:capitalName:) called Country.deinit called City.deinit called */
print("==========")



// 下面的代码仅作试验用，实际上不能为nil
var country2: Country? = Country(name: "China",capitalName: "Beijing")
print("==========")
country2!.capitalCity = nil
print("==========")
country2 = nil
/* City.init(name:country:) called Country.init(name:capitalName:) called ========== City.deinit called ========== Country.deinit called */

在上面的代码中，根据两段式构造过程，Country的构造函数调用了City的构造函数。然而，只有Country的实例完全初始化后，Country的构造函数才能把self传给City的构造函数。

在构造器中，上面的代码通过一条语句同时创建Country和City的实例，而不产生循环强引用。

闭包引起的循环强引用

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

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

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

class HTMLElement {

    let name: String
    let text: String?

    lazy var asHTML: Void -> String = {     // 闭包，即“一个没有参数，返回String的函数”，且asHTML为闭包的强引用
        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
        print("HTMLElement.init(name:text:) called")
    }

    deinit {
        print("HTMLElement.init called")
    }
}

// 可以像实例方法那样去命名、使用asHTML属性。然而，由于asHTML是闭包而不是实例方法，如果你想改变特定HTML元素的处理方式的话，可以用自定义的闭包来取代默认值。
let heading = HTMLElement(name: "h1")   // HTMLElement.init(name:text:) called
let defaultText = "some default text"
heading.asHTML = {
    return "<(heading.name)>(heading.text ?? defaultText)</(heading.name)>"
}
print(heading.asHTML())     // <h1>some default text</h1>

// 正常使用
var h: HTMLElement? = HTMLElement(name: "p",text: "Hello,world!")   // HTMLElement.init(name:text:) called
print(h!.asHTML())   // <p>Hello,world!</p>

h = nil     // 由于HTMLElement类产生了类实例和作为asHTML默认值的闭包之间的循环强引用，此时去打破h持有的HTMLElement实例的强引用，HTMLElement实例和它的闭包都不会被销毁。

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

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

但是，HTMLElement类产生了类实例和作为asHTML默认值的闭包之间的循环强引用。

实例的asHTML属性持有闭包的强引用。但是，闭包在其闭包体内使用了self（引用了self.name和self.text），因此闭包捕获了self，这意味着闭包又反过来持有了HTMLElement实例的强引用。这样两个对象就产生了循环强引用。（具体查阅“闭包”一章中的“值捕获”小节）

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

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

解决闭包引起的循环强引用

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

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

定义捕获列表

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

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

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

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

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

弱引用和无主引用

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

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

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

class HTMLElement {

    let name: String
    let text: String?

    lazy var asHTML: Void -> String = {     // asHTML为闭包的强引用
        [unowned self] in       // 将self捕获为无主引用
        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
        print("HTMLElement.init(name:text:) called")
    }

    deinit {
        print("HTMLElement.deinit called")
    }
}

var h: HTMLElement? = HTMLElement(name: "p",world!")   // HTMLElement.init(name:text:) called
print(h!.asHTML())   // <p>Hello,world!</p>

h = nil     // HTMLElement.deinit called，正确析构了

此时，闭包以无主引用的形式捕获self，并不会持有HTMLElement实例的强引用。如果将h赋值为nil，HTMLElement实例将会被销毁。