自动引用计数、循环引用（这个必须理解，必须看）

注：本文详细介绍自动引用计数，以及各种循环引用问题。一网打尽！

1、 自动引用计数原理

Swift 使用ARC机制来跟踪和管理你的内存，一般情况下，Swift 的内存管理机制会一直起着作用，你无须自己来考虑内存的管理。ARC 会在类的实例不再被使用时，自动释放其占用的内存。

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

为了确保在使用中的实例不会被销毁 ， ARC会跟踪和计算每一个实例正在被多少属性、常量或者变量所使用，直到引用计数为 0 ，ARC就会销毁这个实例

所以，无论你将实例赋值给属性、变量或者常量的时候，他们都回创建此实例的强引用 ，会将实例保持住（引用计数+1） 只要强引用还在，实例是不允许销毁的 。
下面来看一个例子就能轻松理解啦！

class Student{

    var name:String
    init(name:String){
        self.name = name;
        print("\(name) 实例被创建了 ")
    }

    deinit{
        print("\(self.name) 实例被销毁啦！！！")
    }

}

var st1:Student?
var st2:Student?
var st3:Student?

//这里是一个强引用
st1 = Student(name:"张三") //张三 实例被创建了
st2 = st1
st3 = st1
//现在Student有三个强引用了 
st1=nil;
st2=nil
//将这两个释放 ，这时候还有一个强引用 
st3 = nil //张三 实例被销毁啦！！！
//这时候所有的强引用都释放 ， 则释放这个实例

这里注释写的很清楚 ， 只有当所有的强引用释放掉 ，ARC才会释放这个实例

我们有时候会写出循环强引用的代码 。 如果两个实例互相持有对方的强引用 ，所以每个实例都会让对方一直存在着，一直不会被销毁 ，这就是所谓的循环强引用 。

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

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

下面我们先来了解一下他是怎么产生的 ：

class Animal {
    var name:String
    var food:Food?

    init(name:String){
        self.name = name
    }

    deinit{
        print("Animal 被销毁啦")
    }
}


class Food {
    var name:String
    var animal:Animal?

    init(name:String){
        self.name = name
    }
    deinit{
        print("Food 被销毁啦 ")
    }
}

这里在Animal类中引用了Food 在Food中引用了Animal ，都是强引用

var dog:Animal? = Animal(name: "dog")
var dogFood:Food? = Food(name: "meat")

dog!.food = dogFood
dogFood!.animal=dog
dog = nil
dogFood = nil

然而并不会调用析构函数 ，循环引用会一直阻止这两个实例被销毁 应用程序造成了内存泄露

• 解决循环强引用问题

Swift提供了两种办法来解决这个问题 弱引用 和 无主引用 对于生命周期中会变成nil的实例 使用弱引用 ，对于初始化赋值后。再也不会被赋值为nil的实例使用无主引用。

a 、弱引用

class Animal1 {
    var name:String
    var food:Food1?

    init(name:String){
        self.name = name
    }

    deinit{
        print("Animal1 被销毁啦")
    }
}


class Food1 {
    var name:String
    weak var animal:Animal1?

    init(name:String){
        self.name = name
    }
    deinit{
        print("Food1 被销毁啦 ")
    }
}

var dog1:Animal1? = Animal1(name: "dog")
var dogFood1:Food1? = Food1(name: "meat")

dog1!.food = dogFood1
dogFood1!.animal=dog1

dogFood1 = nil
dog1 = nil

//Animal1 被销毁啦
//Food1 被销毁啦
//哈哈 两个都可以被销毁啦

b 、无主引用
无主引用也不会牢牢保持住引用的实例 ， 和弱引用不同 ，无主引用永远是有值得 。无主引用总是被定义位非可选类型 。你可以在声明的时候在前面加上关键字 unowend 来表示这是个无主引用
ARC无法在实例销毁的时候将它设置位nil 因为非可选的变量永远不能被赋值为nil ，但是在实例销毁后也是无法用这个实例去访问无主引用的， 如果你强制访问 会报运行时错误

class Customer {
    var name:String

    var card:Card?
    init(name:String){
        self.name = name
    }
    deinit{
        print("Customer 被销毁")
    }
}
class Card {
    var name:String
    unowned var customer:Customer    //一个卡肯定要对应一个顾客
    init(name:String,cus:Customer){
        self.name = name
        self.customer = cus
    }
    deinit{
        print("Card 被销毁")
    }
}


var customer:Customer? = Customer(name: "张三")
var card:Card? = Card(name: "招商银行金卡",cus: customer!)

customer!.card = card
customer = nil
card = nil
//Customer 被销毁
//Card 被销毁
//card!.customer //fatal error: unexpectedly found nil while unwrapping an Optional value

这个也被顺利的销毁 ，当销毁后再取访问的时候就不能访问了

前面两种解决循环引用的场景 ，第一种是两个都允许为nil,第二个是有一个不允许为nil，但是如果两个属性都不允许位nil ，初始化完成后永远不能为nil ，这时候就需要一个类使用无主 ， 另一个使用隐式解析可选属性
c、隐式解析可选属性

class Country{
    var name:String
    var city:City!
    init(name:String,cityName:String){
        self.name = name
        self.city = City(name: cityName,country: self)
    }

    deinit{
        print("Country 被销毁啦 ")
    }
}


class City{

    var name:String
    unowned var country:Country

    init(name:String,country:Country){
        self.name = name
        self.country=country
    }
    deinit{
        print("City 被销毁啦")
    }
}

var country:Country? = Country(name: "China",cityName: "ShangHai")
//这一条语句创建了两个实例

var city = country!.city
print(city.country.name) //China 

city = nil
country!.city = nil //City 被销毁啦
country = nil //Country 被销毁啦

这里注释都写的很清楚，代码很简单 ，就不再赘述

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

循环强引用还会发生在你将一个闭包赋值给一个类的属性 ， 闭包中又使用了这个类的实例 ，其实 这跟之前的是一样的 ，因为闭包也是引用类型的 ， 你把一个引用类型赋值给一个属性 ，然后在这个引用类型中使用这个实例 ，两个强引用一直有效.
使用闭包捕获列表可以解决这个问题

下面看看 这个问题是怎么产生的 .

class Book{
    var name:String
    //这里定义为lazy才可以使用self 。在构造器第一阶段还不能使用self
    lazy var oldName:Void -> String = {
        return "old\(self.name)"
    }

    init(name:String){
        self.name = name
    }
    deinit{
        print("Book 被销毁了")
    }

}

var book:Book? = Book(name: "Swift书")
print(book!.oldName()) //oldSwift书
//oldName是一个闭包
book = nil

这时候并没有打印出析构方法的句子。明显产生了循环引用

解决办法 ：
定义捕获列表：捕获列表中的每一项都由一对元素组成 ，一个是weak 或者 unowned ，另一个是类的实例或者初始化变量

class Book1{
    var name:String
    //这里定义为lazy才可以使用self 。在构造器第一阶段还不能使用self
    lazy var oldName:Void -> String = {
        [unowned self] in
        return "old\(self.name)"
    }

    init(name:String){
        self.name = name
    }
    deinit{
        print("Book 被销毁了")
    }

}

var book1:Book1? = Book1(name: "Swift书")
print(book1!.oldName()) //oldSwift书
//oldName是一个闭包
book1 = nil  //Book 被销毁了

这时会就被顺利销毁了

看下语法 ：

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

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

按照上述两种语法就可以了。

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

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