官方文档

Swift使用自动引用计数(ARC)机制来追踪和管理你的app的内存。在大多数情况，这意味着Swift的内存管理机制会一直起作用，你不需要自己考虑内存管理。当不再需要类的实例时，ARC会自动释放类所占用的内存。

然而，在少数情况下，ARC为了能帮助你管理内存，需要更多的关于你的代码之间关系的信息。本章描述了这些情况，以及向你展示如何启用ARC来管理你的app的内存。

注意

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

ARC的工作机制

每次你创建一个类的实例，ARC会分配一大块内存来存储实例的信息。这些内存中保留有实例类型的信息，以及该实例所有存储属性的值信息。

此外，当实例不需要时，ARC会释放该实例所占用的内存，释放的内存用于其他用途。这确保类实例当它不在需要时，不会一直占用内存。

然而，如果ARC释放了正在使用的实例内存，那么它将不会访问实例的属性，或者调用实例的方法。确实，如果你试图访问该实例，你的app很可能会崩溃。

为了确保使用中的实例不会消失，ARC会跟踪和计算当前实例被多少属性，常量和变量所引用。只要存在对该类实例的引用，ARC将不会释放该实例。

为了使这些成为可能，无论你将实例分配给属性，常量或变量，它们都会创建该实例的强引用。之所以称之为“强(strong)”引用，是因为它会将实例保持住，只要强引用还在，实例是不允许被销毁的。

ARC

下面的例子，展示了自动引用计数的工作机制。这个例子由一个简单的Person类开始，定义了一个名为name的存储常量属性:

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

Person类有一个初始化器，它设置了实例的name属性并且输出一条信息表明初始化器生效。Person类也有一个反初始化器，会在类的实例被销毁的时候打印一条信息。

下面的代码片段定义了三个Peroson?类型的变量，用来按照代码中的顺序，为新的Person实例设置多个引用。由于可选类型的变量会被自动初始化为一个nil值，目前还不会引用到Person类的实例。

var reference1: Person?
var reference2: Person?
var reference3: Person?

你可以创建一个新的Person实例并且将它赋值给三个变量中的一个：

reference1 = Person(name: "John Appleseed")
// prints "John Appleseed is being initialized"

注意，当调用person类的出初始化器的时候，会输出"John Appleseed is being initialized"信息。这就说明初始化执行了。

因为Person实例已经赋值给了reference1变量，现在就有了一个从reference1到该实例的强引用。因为至少有一个强引用，ARC可以确保Person一直保持在内存中不被销毁。

如果你将同一个Person实例分配给了两个变量，则该实例又会多出两个强引用：

reference2 = reference1
reference3 = reference1

现在这一个Person实例就有了三个强引用。

如果你通过给其中两个变量赋值nil的方式断开两个强引用（包括最先的那个强引用），只留下一个强引用，Person实例不会被销毁：

reference1 = nil
reference2 = nil

在你清楚地表明不再使用这个Person实例时，即第三个也就是最后一个强引用被断开时ARC 会销毁它。

reference3 = nil
// prints "John Appleseed is being deinitialized"

类实例之间的循环强引用

在上面的例子中，ARC能够追踪你所创建的Person实例的引用数量，并且会在Person实例不在使用时销毁。

然而，永远不要写出类实例强引用为0的代码。如果两个类实例彼此持有一个强引用，因而每个实例都让对方一直存在，就可能发生这种情况。这就是所谓的循环强引用。

解决循环强引用问题，可以通过定义类之间的关系为弱(weak)引用或无主(unknown)引用来代替强引用。这个过程在解决类实例之间的循环强引用中有描述。然而，在你学习时如何解决循环强引用问题，就很有必要了解它是如何产生的。

下面的例子展示了一个如何错误创建一个循环强引用。这个例子定义了两个类，分别是Person和Apartment，用来建模公寓和它其中的居民:

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

每一个Person实例有一个类型为String，名字为name的属性，并有一个可选的初始化为nil的apartment属性。apartment属性是可选的，因为一个人并不总是拥有公寓。

类似的，每个Apartment实例有一个叫number，类型为Int的属性，并有一个可选的初始化为nil的tenant属性。tenant属性是可选的，因为一栋公寓并不总是有居民。

这两个类都定义了析构函数，用以在类实例被析构的时候输出信息。这让你能够知晓Person和Apartment的实例是否像预期的那样被销毁。

接下来的代码片段定义了两个可选类型的变量john和unit4A，并分别被设定为下面的Apartment和Person的实例。这两个变量都被初始化为nil，这正是可选的优点：

var john: Person?
var unit4A: Apartment?

现在你可以创建特定的Person和Apartment实例并将赋值给john和unit4A变量：

john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")

在两个实例的强引用创建和分配之后，下图表现了强引用的关系。John变量对Person实例有一个强引用，unit4A变量对Apartment实例有一个强引用:

现在你可以把这两个实例关联在一起，这样人就有公寓了，而且公寓有房间号。注意，感叹号(!)是用来展开和访问可选变量john和unit4A的实例，所以这些实例的属性可以被设置:

john!.apartment = unit4A
unit4A!.tenant = john

在将两个实例联系在一起之后，强引用的关系如图所示：

不幸的是，这两个实例关联后会产生一个循环强引用。Person实例现在有了一个指向Apartment实例的强引用，而Apartment实例也有了一个指向Person实例的强引用。因此，当你断开john和unit4A变量所持有的强引用时，引用计数并不会降为 0，实例也不会被 ARC 销毁：

john = nil
unit4A = nil

注意，当你把这两个变量设为nil时，没有任何一个析构函数被调用。循环强引用会一直阻止Person和Apartment类实例的销毁，这就在你的应用程序中造成了内存泄漏。
在你将john和unit4A赋值为nil后，强引用关系如下图：

Person和Apartment实例之间的强引用关系保留了下来并且不会被断开。

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

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

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

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

若引用

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

在实例的生命周期中，当引用可能没有值的时候，可以使用弱引用来避免循环引用。如果引用始终有值，则可以使用无主引用来代替。在无主引用中描述。上面的Apartment例子中，在它的声明周期中，有时是"没有居民"的，因此适合使用弱引用来解决循环强引用。

注意

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

因为若引用允许"没有值"，你必须声明每个若引用为一个可选类型。在 Swift 中，推荐使用可选类型描述可能没有值的类型。

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

下面的例子跟上面Person和Apartment的例子一致，但是有一个重要的区别。这一次，Apartment的tenant属性被声明为弱引用：

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

然后跟之前一样，建立两个变量（john和unit4A）之间的强引用，并关联两个实例：

var john: Person?
var unit4A: Apartment?
john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")
john!.apartment = unit4A
unit4A!.tenant = john

现在，两个关联在一起的实例的引用关系如下图所示：

Person实例依然保持对Apartment实例的强引用，但是Apartment实例只是对Person实例的弱引用。这意味着当你断开john变量所保持的强引用时，再也没有指向Person实例的强引用了：

由于再也没有指向Person实例的强引用，该实例会被销毁：

john = nil
// prints "John Appleseed is being deinitialized"

唯一剩下的指向Apartment实例的强引用来自于变量unit4A。如果你断开这个强引用，再也没有指向Apartment实例的强引用了：

由于再也没有指向Apartment实例的强引用，该实例也会被销毁：

unit4A = nil
// prints "Apartment 4A is being deinitialized"

无主引用

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

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

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

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

Customer和CreditCard之间的关系与前面弱引用例子中Apartment和Person的关系略微不同。在这个数据模型中，一个客户可能有或者没有信用卡，但是一张信用卡总是关联着一个客户。为了表示这种关系，Customer类有一个可选类型的card属性，但是CreditCard类有一个非可选类型的customer属性。

由于信用卡总是关联着一个客户，因此将customer属性定义为无主引用，用以避免循环强引用：

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

注意: CreditCard类的number属性被定义为UInt64类型而不是Int类型，以确保number属性的存储量在32位和64位系统上都能足够容纳16位的卡号。

下面的代码片段定义了一个叫john的可选类型Customer变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为nil。

var john: Customer?

你可以创建一个Customer实例，用它初始化和分配一个新的CreditCard实例作为customer的card属性:

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

如下图，是你关联了两个实例后的图示关系:

现在Customer实例对CreditCard实例有一个强引用，并且CreditCard实例对Customer实例有一个无主引用。

由于Customer的无主引用，当你断开john变量持有的强引用时，那么就再也没有指向Customer实例的强引用了。

因为不在有Customer的强引用，该实例被销毁了。其后，再也没有指向CreditCard实例的强引用，该实例也随之被销毁了：

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。在这种场景中，需要一个类使用无主属性，而另外一个类使用隐式解析可选属性。

一旦初始化完成，这两个属性能被直接访问(不需要可选展开)，同时避免了循环引用。这一节将为你展示如何建立这种关系。

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

class Country {
    let name: String
    var 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: Stirng, country: Country) {
        self.name = name
        self.country = country
    }
}

为了建立两个类的依赖关系，City的初始化函数有一个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")
print("\\(country.name)'s capital city is called \\(country。capitalCity.name)")
// prints "Canada's capital city is called Ottawa"

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

闭包引起的循环强引用

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

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

循环强引用的产生，是因为闭包和类相似，都是引用类型。当你把闭包分配给了一个属性，你也把一个引用分配给了这个闭包。实质上，这跟之前上面的问题是一样的--两个强引用让彼此一直有效。然而，和两个类实例不同，这次一个是类实例，另一个是闭包。

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

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

class HTMLElement {
    let name: String
    let text: String?
    lazy var asHTML: Void -> String = {
        if var asNTML = 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属性来表示这个元素的名称，例如代表段落的"p"，或者代表换行的"br"。HTMLElement还定义了一个可选属性text，用来设置和展现 HTML 元素的文本。

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

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

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

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

HTMLElement类只提供一个构造函数，通过name和text（如果有的话）参数来初始化一个元素。该类也定义了一个析构函数，当HTMLElement实例被销毁时，打印一条消息。

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

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

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

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

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

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

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

paragraph = nil

注意HTMLElementdeinitializer中的消息并没有被打印，证明了HTMLElement实例并没有被销毁。

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

你可以通过定义捕获列表作为闭包的定义来解决在闭包和类实例之间的循环强引用。捕获列表定义了当在闭包体里捕获一个或多个引用类型的规则。正如在两个类实例之间的循环强引用，声明每个捕获的引用为引用或无主引用而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。

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

定义捕获列表

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

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

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

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

lazy var someClosure: Void -> String = {
    [unowned self, weak delegate = self.delegate!] in
    // closure body goes here
}

弱引用和无主引用

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

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

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

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

class HTMLElement {
    let name: String
    let text: String?
    lazy var asHTML: Void -> 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())
// prints "<p>hello, world</p>"

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

这一次，闭包以无主引用的形式捕获self，并不会持有HTMLElement实例的强引用。如果将paragraph赋值为nil，HTMLElement实例将会被销毁，并能看到它的反初始化函数打印出的消息。

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

了解更多关于捕获列表，请看捕获列表。