Swift自动引用计数 - 解决内存泄露

1、自动引用计数概念 

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

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

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

2、通过代码分析ARC

class Person {
    let name: String
   
    init(name: String) {
        self.name = name
        println("\(name) is being initialized")
    }
   
    deinit {
        println("\(name) is being deinitialized")
    }
}

// 定义三个可选的Person类型变量，因为我们随时可能销毁这个实例
var reference1: Person?
var reference2: Person?
var reference3: Person?

// 通过赋值 在变量和Person类的实例之间建立了一个强引用。

//  正是因为这个强引用，ARC 会保证Person实例被保持在内存中不被销毁。
reference1 = Person(name: "John Appleseed”)

reference2 = reference1
reference3 = reference1

// 当我们销毁只2个变量的时候，Person实例不会被销毁

reference1 = nil
reference2 = nil

//只要当所有变量都销毁，Person实例才会被销毁

reference3 = nil

3、 类实例之间的循环强引用

我们可能会写出这样的代码，一个类永远存在强引用。这种情况发生在两个类实例互相保持对方的强引用，并让对方不被销毁。这就是所谓的循环强引用。

例如：下面有2个类，他们相互都有一个属性用来保存对方的实例

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { println("\(name) is being deinitialized") }
}

class Apartment {
    let number: Int
    init(number: Int) { self.number = number }
    var tenant: Person?
    deinit { println("Apartment #\(number) is being deinitialized") }
}

// 初始化变量

var john: Person?
var number73: Apartment?

// 把类实例化赋予给变量

john = Person(name: "John Appleseed")
number73 = Apartment(number: 73)

//  把两个实例关联在一起。注意感叹号是用来展开和访问可选变量john和number73中的实例，这样实例的属性才能被赋值

john!.apartment = number73
number73!.tenant = john

注： 当将这两个实例关联在一起之后，一个循环强引用被创建了， 强引用循环阻止了Person和Apartment类实例的销毁，并在你的应用程序中造成了内存泄漏。

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

Swift可以使用 弱引用（weak reference）和无主引用（unowned reference）来解决循环强引用问题。

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

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

5、声明弱引用 （weak reference）

声明属性或者变量时，在前面加上weak关键字表明这是一个弱引用。

弱引用必须被声明为变量，表明其值能在运行时被修改。

注：在实例的生命周期中，如果某些时候引用没有值即nil，则使用 弱引用来 阻止循环强引用。如果引用总是有值，则可以使用无主引用。

在上面Apartment的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。

class Apartment {
    let number: Int
    init(number: Int) { self.number = number }
    weak var tenant: Person?
    deinit { println("Apartment #\(number) is being deinitialized") }
}

这意味着当你销毁john变量时，再也没有指向Person实例的强引用了，则 该实例会被销毁。由于Person实例被销毁了， 再也没有指向Apartment实例的强引用，该实例同样也会被销毁。

6、声明 无主引用 （unowned reference）

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

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

例如：下面的例子定义了两个类，Customer和CreditCard，模拟了银行客户和客户的信用卡。这两个类中，每一个都将另外一个类的实例作为自身的属性。这种关系会潜在的创造循环强引用。

因为用户不一定有信用卡，但是信用卡必定有一个用户，所以Customer类有一个可选类型的card属性，但是CreditCard类有一个非可选类型的customer属性。

此外在实例化CreditCard类的时候，必须要传入一个Customer对象，因为这样才能确保每个CreditCard都有所属者。

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") }
}

//初始化变量

var john: Customer?

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

//销毁变量

john = nil

Customer实例持有对CreditCard实例的强引用，而CreditCard实例持有对Customer实例的无主引用。由于customer的无主引用，当你断开john变量持有的强引用时，再也没有指向Customer实例的强引用了，则Customer实例会被销毁。

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

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

Person和Apartment的例子展示了两个属性的值都允许为nil，并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。

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

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

下面的例子定义了两个类，Country和City，每个类将另外一个类的实例保存为属性。在这个模型中，每个国家必须有首都，而每一个城市必须属于一个国家。为了实现这种关系，Country类拥有一个capitalCity属性，而City类有一个country属性：

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
    }
}

Country的构造函数调用了City的构造函数。只有Country的实例完全初始化完后，Country的构造函数才能把self传给City的构造函数。

为了满足这种需求，通过在类型结尾处加上感叹号（City!）的方式，将Country的capitalCity属性声明为隐式解析可选类型的属性。 这表示像其他可选类型一样，capitalCity属性的默认值为nil，但是不需要展开它的值就能访问它。

由于capitalCity默认值为nil，一旦Country的实例在构造函数中给name属性赋值后，整个初始化过程就完成了。这代表一旦name属性被赋值后，Country的构造函数就能引用并传递隐式的self。Country的构造函数在赋值capitalCity时，就能将self作为参数传递给City的构造函数。

以上的意义在于你可以通过一条语句同时创建Country和City的实例，而不产生循环强引用，并且capitalCity的属性能被直接访问，而不需要通过感叹号来展开它的可选值：

var country = Country(name: "Canada", capitalName: "Ottawa”)

在上面的例子中，使用隐式解析可选值的意义在于满足了两个类构造函数的需求。capitalCity属性在初始化完成后，能像非可选值一样使用和存取同时还避免了循环强引用。

8、 闭包引起的循环强引用

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

循环强引用的产生，是因为闭包和类相似，都是引用类型。 实质上，这跟之前的问题是一样的－两个强引用让彼此一直有效。但是，和两个类实例不同，这次一个是类实例，另一个是闭包。

下面的例子为你展示了当一个闭包引用了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 {
        println("\(name) is being deinitialized")
    }
   
}

HTMLElement定义了一个lazy属性asHTML。这个属性引用了一个闭包，将name和text组合成 HTML 字符串片段。该属性是() -> String类型，或者可以理解为“一个没有参数，返回String的函数”。

默认情况下，闭包赋值给了asHTML属性，这个闭包返回一个代表 HTML 标签的字符串。

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

// 实例化

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

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

实例的asHTML属性持有闭包的强引用；同时 闭包在其闭包体内使用了self，因此闭包捕获了self，这意味着闭包又反过来持有了HTMLElement实例的强引用。这样两个对象就产生了循环强引用。

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

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

在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。

捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。 跟解决两个类实例间的循环强引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。

10、 定义捕获列表

捕获列表中的每个元素都是由weak或者unowned关键字和实例的引用（如self或someInstance）成对组成。每一对都在方括号中，通过逗号分开。

捕获列表放置在闭包参数列表和返回类型之前：

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

如果闭包没有指定参数列表或者返回类型，则可以通过上下文推断，那么可以捕获列表放在闭包开始的地方，跟着是关键字in：

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

11、闭包的 弱引用和无主引用

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

（2） 当捕获引用有时可能会是nil时，将闭包内的捕获定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为nil。

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

    lazy var asHTML: () -> String = {
        [unowned self] in
        if let text = self.text {
            return "<\(self.name)>\(text)</\(self.name)>"
        } else {
            return "<\(self.name) />"
        }
    }

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