参考书籍：
[1]管蕾.张玲玲.朱元波.Swift开发实战[M]. 北京：人民邮电出版社.2014.10-1 ISBN 978-7-115-36827-0
[2]陈隽.刘媛媛.Swift入门很简单[M]. 北京：清华大学出版社.2015.01-01 ISBN 978-7-302-38880-7
自动引用计数ARC是一种内存管理机制，用来跟踪、管理开发者应用程序所使用的内存。
一、工作机制
开发者每一次创建一个类实例时，ARC会分配一块内存用来管理存储实例相关的信息，比如实例的类型信息、与实例相关的属性值。当实例不再被使用时，ARC将会释放此实例所占的内存。这样保证不会使用的内存不会一直占用内存空间。
示例代码：
import Foundation
class Person{
let name:String
init(name: String){
self.name = name
print("\(name) start to init.")
}
deinit {
print("\(name) was freed ")
}
}
var referencel: Person? = Person(name: "John")//创建实例时，ARC将会分配内存
referencel = nil//设置为nil是，ARC释放内存
John start to init.
John was freed
Program ended with exit code: 0
修改版1，访问被释放的实例属性：
import Foundation
class Person{
let name:String
init(name: String){
self.name = name
print("\(name) start to init.")
}
deinit {
print("\(name) was freed ")
}
}
var referencel: Person? = Person(name: "John")
referencel = nil
print(referencel?.name)
终端如下：
John start to init.
John was freed
nil
Program ended with exit code: 0
解释：访问已经被释放的实例或方法，将会得到nil
修改版2，强制访问被释放的实例属性：
import Foundation
class Person{
let name:String
init(name: String){
self.name = name
print("\(name) start to init.")
}
deinit {
print("\(name) was freed ")
}
}
var referencel: Person? = Person(name: "John")
referencel = nil
print(referencel!.name)
John start to init.
John was freed
fatal error: unexpectedly found nil while unwrapping an Optional value
(lldb)
即，强制访问会导致程序崩溃。
二、循环强引用
开发者可能会写出“在程序中使用多个强引用”，而这些强引用不知不觉形成循环强引用，而导致内存泄露。
1、类实例之间循环强引用
多个类互相保留对方的强引用，并让对方不被销毁。例如:
import Foundation
class Person{
let name:String
init(name: String){
self.name = name
print("\(name) start to init.")
}
var apartment: Apartment? //属性声明
deinit {
print("\(name) was freed ")
}
}
class Apartment{
let number: Int
init(number: Int){
self.number = number
}
var tenant: Person?//属性声明
deinit{
print("Apartment #\(number) was freed")
}
}
var referencel: Person? = Person(name: "John")
var number: Apartment? = Apartment(number: 74)
print(referencel?.name)
print(number?.number)
referencel!.apartment=number//为对象中的属性赋值
number!.tenant = referencel//为对象中的属性赋值
referencel = nil
number = nil
终端如下：
John start to init.
Optional(“John”)
Optional(74)
Program ended with exit code: 0
上例，两个实例创建循环强引用，导致引用计数并不会将为0，实例未被ARC销毁。
2、闭包引起的循环强引用
即，开发者将一个闭包赋值给类实例的某个属性时，在这个闭包体中又使用了实例，或者闭包体中可能访问了实例的某个属性、方法，导致产生循环强引用。
例如：
import Foundation
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) was freed")
}
}
var paragraph: HTMLElement? = HTMLElement(name: "p" , text: "Hello,world")
print(paragraph!.asHTML())
paragraph = nil
终端：
<p>Hello,world</p>
Program ended with exit code: 0
上面例子中，闭包实现的功能是赋值给asHTML属性，返回一个代表HTML标签的字符串。
使用HTMLElement创建的实例和asHTML默认值的闭包之间的循环强引用，使得paragraph设置为nil时，ARC没有释放实例。
HTMLElement类的实例name:”p” – strong -> ()->String中self.name
HTMLElement类的实例text:”hello world”<- strong – ()->String中self.text
三、循环强引用解决方法
1、解决实例之间的循环强引用
1.1 弱引用
弱引用不会牢牢保留住引用实例，不会阻止ARC销毁被引用的实例，这种行为阻止了引用变为循环强引用。
例如：
import Foundation
class Person{
let name:String
init(name: String){
self.name = name
print("\(name) start to init.")
}
var apartment: Apartment?
deinit {
print("\(name) was freed ")
}
}
class Apartment{
let number: Int
init(number: Int){
self.number = number
}
weak var tenant: Person?//使用weak关键字（必须为可变存储属性）
deinit{
print("Apartment #\(number) was freed")
}
}
var referencel: Person? = Person(name: "John")
var number: Apartment? = Apartment(number: 74)
print(referencel?.name)
print(number?.number)
referencel!.apartment=number
number!.tenant = referencel
referencel = nil
number = nil
终端如下（成功释放）：
John start to init.
Optional(“John”)
Optional(74)
John was freed
Apartment #74 was freed
Program ended with exit code: 0
1.2 无主引用
无主引用也不会保留引用的实例，和弱引用不同的是，无主引用永远有值。因此无主引用总是被定义为非可选类型。
开发者声明属性或者变量/常量是，在前面加上关键字unowned表示这是一个无主引用，语法形式：
unowned let/var 属性/常量/变量:实例
1.3 无主引用和隐式解析可选属性
2、解决闭包所引起的循环强引用
闭包所引起的循环强引用，可以通过定义闭包的同时定义捕获列表作为闭包的一部分解决。捕获列表定义了闭包内捕获一个或者多个引用类型的规则。跟解决类实例键的循环强引用一样，需要声明每个捕获的引用为弱引用或无主引用。
2.1定义捕获列表
捕获列表中每个元素都是由weak 或unowned关键字和实例引用（如self或someInstance）成对组成。每一对都是方括号内，通过逗号分开，定义形式如下：
[关键字 self]
2.2若引用和无主引用
当闭包和捕获的实例总是相互作用，并且总是同时销毁时，将闭包内的捕获定义为无主引用；相反，当捕获引用有时可能为nil时，将闭包内捕获定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用值会自动置为nil。这可以让开发者在闭包内检查他们是否存在。
例如：使用捕获列表解决循环强引用
import Foundation
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) was freed")
}
}
var paragraph: HTMLElement? = HTMLElement(name: "p" , text: "Hello,world")
print(paragraph!.asHTML())
paragraph = nil
终端如下（成功释放）：
<p>Hello,world</p>
p was freed
Program ended with exit code: 0