Swift 自动引用计数(ARC)

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

自动引用计数的工作机制

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

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

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

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

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

自动引用计数主要有两大贡献如下:

1：跟踪内存中的实例被哪些类属性,常量或者变量所引用.

2：在没有类属性,常量或者变量引用该实例时,释放该实例在内存中所占的空间.

强引用

在 Swift中,当我们把一个类实例赋值给一个类属性,常量或者变量时,Swift都会自动帮我们创建一个类属性,常量或者变量到该实例的引用,该引用确保了 ARC 不会析构此类的实例,我们把这种确保 ARC 不自动析构该实例的引用叫做强引用.

强引用的用法: 年轻都有一个江湖梦,快意恩仇,一把长剑满腹豪情,如杨过,郭靖等都是大侠,当然也有一类人是被江湖所唾弃,比如恶贯满盈段延庆,下面使用段延庆来说明强引用的用法.

class People{

var type: String
var name: String

//指定构造器方法,设置名称和类型
init(name: String ,type: String){

self.name = name
self.type = type

print("\(type)\(name) 诞生于江湖!")
}

//便捷构造器.
convenience init(){

self.init( name:"无名氏",type: "江湖好汉")
}

//析构器方法,该类的实例被 ARC 回收时调用
deinit{

print("该实例被回收,内存释放,也就是说\(self.name)离开江湖,不再存在了!")
}
}

//该部分可以打断点测试
func testOne(){

//定义一个名为段延庆的实例.  这里注意一点duanYanQing是可选类型,因为后面我们需要设置为nil;来告诉 ARC, 我们不使用该实例了.
var  duanYanQing: People? = People(name: "段延庆", type: "大恶人")

//大理王子也是段延庆,所以daLiWangZi变量指向了duanYanQing这个实例.
var daLiWangZi = duanYanQing

//恶人之首也是段延庆,所以eRenZhiShou变量指向了段延庆这个实例.
var eRenZhiShou = duanYanQing

//大理王子被除名,不复存在,所以设置为nil.
daLiWangZi = nil

//恶人之首也不复存在,所以设置为nil
eRenZhiShou = nil

//段延庆也不复存在,所以设置为nil
duanYanQing = nil

/*
打印结果:
大恶人段延庆 诞生于江湖!
该实例被回收,内存释放,也就是说段延庆离开江湖,不再存在了!
分析:

1:在代码中相继定义了两个变量daLiWangZi和eRenZhiShou,它们在赋值的过程中会延续duanYanQing的类型,也是 People? .
2:虽然有三个变量指向了同一个 People实例,但是因为指向同一个实例,所以构造器方法只调用了一次.
3:当3个变量全都设置为nil,也就是段延庆渣江湖上没有任何名号了,也就是该实例被 ARC 回收了,内存被销毁了.
4:以上3个变量都指向段延庆的这个People实例, ARC会为其生成三个引用.有三个强引用指向它,所以ARC不会收回这块内存,只有当这3条强引用全部消除时,这个实例才会被销毁,内存才会被回收.

*/
}

2: 闭环与解环

//男生类
class Male {

let name: String
//每个男人都可能有女朋友也可能没有女朋友
var girlFriend: Female?

init(name: String){

self.name = name
}

deinit{

print("男人\(name)实例被销毁")
}
}

//女生类
class Female {

let name: String
//当然女生也一样,不见得每个女生都有男朋友
var boyFriend: Male?

init(name: String){

self.name = name
}

deinit{

print("女人\(name)实例被销毁")
}

}

func testTwo(){

//男人jack出场
var man:Male? = Male(name: "jack")

//女人rose出场
var woman: Female? = Female(name: "rose")

//man中的girlFriend指向woman,强引用,woman中的boyFriend指向man,所以产生了强引用环.
man!.girlFriend = woman
woman!.boyFriend = man

//如果man和woman这两个实例不再使用了,我们给其赋值为nil,让 ARC回收
print("jack和rose完成了人生使命,我们告诉 ARC 这两个实例不再使用了!")
man = nil
woman = nil

print("不知道这两个实例被回收了没有!")

/*

打印结果:
jack和rose完成了人生使命,我们告诉 ARC 这两个实例不再使用了!
不知道这两个实例被回收了没有!

分析:
虽然我们将man,woman设置为nil,告诉 ARC 这两个实例不用了,可是上面结果并没有显示实例被回收的信息,说明 ARC 并没有正确地回收.这就是我们经常遇到的问题,强引用环.为什么呢?
当 ARC 发现 man变量和woman变量被设置为nil,准备释放对象,但是却发现 man中的girlFriend指向woman,所以等待woman释放.同理woman也要等待 man释放,这样就出现了相互等待的现象.所以造成对象没有被释放.

为了解决强引用环,Swift提供了3种方法:弱引用,无主引用,捕获列表,并且分别对应不同的使用场景.
1:如果被指向的实例有可能为nil,则使用弱引用.
2:如果被指向的实例不为nil,则使用无主引用.
3:如果在类属性使用闭包时,并且闭包体内引用当前实例self而产生强引用环时,则使用捕获列表.

*/

}

3：弱引用 改变之前的Male类和函数部分,Female代码不动.

class Male {
let name: String
//每个男人都可能有女朋友也可能没有女朋友
weak var girlFriend: Female?

init(name: String){

self.name = name
}

deinit{

print("男人\(name)实例被销毁")
}
}

func testThree(){

//男人jack出场
var man:Male? = Male(name: "jack")

//女人rose出场
var woman: Female? = Female(name: "rose")

//man中的girlFriend指向woman,强引用,woman中的boyFriend指向man
//所以产生了强引用环.
man!.girlFriend = woman
woman!.boyFriend = man

//如果man和woman这两个实例不再使用了,我们给其赋值为nil,让 ARC回收
print("jack和rose完成了人生使命,我们告诉 ARC 这两个实例不再使用了!")

// print("woman实例释放前, man.girlFriend的值:\(man!.girlFriend)")
//woman = nil
// print("woman实例释放后, man.girlFriend的值:\(man!.girlFriend)")

print("man实例释放后, woman!.boyFriend的值:\(woman!.boyFriend)")
man = nil
print("man实例释放前, woman!.boyFriend的值:\(woman!.boyFriend)")

woman = nil

/*

打印:
jack和rose完成了人生使命,我们告诉 ARC 这两个实例不再使用了!
woman实例释放前, man.girlFriend的值:Optional(ARC.Female)
女人rose实例被销毁
woman实例释放后, man.girlFriend的值:nil
男人jack实例被销毁

jack和rose完成了人生使命,我们告诉 ARC 这两个实例不再使用了!
man实例释放后, woman!.boyFriend的值:Optional(ARC.Male)
man实例释放前, woman!.boyFriend的值:Optional(ARC.Male)
女人rose实例被销毁
男人jack实例被销毁

分析:
1:经过2次的打印, Swift会主动维护弱引用的值,如man实例中的弱引用girlFriend属性,它指向woman属性,所以当woman实例释放,则girlFriend值会被 Swift重置为nil.
2:强引用和弱引用是不一样的,在强引用结果中,我们可以看到woman的强引用属性boyFriend指向的man实例,不管其释放语法,这个boyFriend的值不会改变!
3:弱引用的定义格式为: weak var 属性.并且注意了弱引用必须是变量类型,因为弱引用的值在运行时会改变.
4:如果某个属性指向的实例有可能为nil,则我们使用弱引用类型.
*/
}

4：解环妙法无主引用

上一个例子中,man实例中的girlFriend属性是一个可选类型,因此我们可以把它定义为一个弱引用,当所有的强引用都注销时,Swift会自动帮我们把这个弱引用改成nil,同时注销整个实例,但如果这个指向类实例的引用不是可选类型,不能够赋值为nil,我们就需要使用无主引用了.

无主引用是由关键字unowned修饰的引用,它和弱引用在用途上完全一样,都是用来打破强引用环,但和弱引用的最大不同是,无主引用总是假定其引用对象一直存在(有值),因而有主引用不能修饰可选类型(注意:在实例被销毁后,还打算通过它的无主引用访问该实例,那么程序会奔溃的).简单来说,只要两个类实例间有形成强引用环的可能,并且满足以下场景,都应该使用关键字unowned修饰类属性:

1：其中一个类实例中的属性为可选类型,即其值可以为nil,而另外一个实例中的属性为非可选类型,不能为 nil.

2：两个类实例中的属性,一旦初始化后,都不能为nil.

场景一 :假设有成年人和小孩这两个类,在成年人这个类中有小孩这个属性,小孩这个类里有保留了成年人这个属性,所以它们之间存在行程强引用环的可能性.因此,我们需要弱引用或者无主引用来打破.但是到底是弱引用还是无主引用呢,来看一下关系,这这两个类关系的模型中,对于成年人来说,小孩是个可选属性,因为并不是所有成年人都决定要小孩,但对于小孩来说,成年人作为监护人在小孩的成长中是必须的,所以我们使用无主引用.

class Adult{

let name: String
init(name: String){

self.name = name
}

var child: Child?
deinit{

print("Adult \(name) 被销毁了!")
}
}

class Child{

let name: String
unowned var guardian: Adult  //无主引用既可以用于常量也可以是变量
init(name: String, guardian: Adult){

self.name = name
self.guardian = guardian
}

deinit{

print("Child \(name) 被销毁了!")
}

}
func testFour(){
//记住:可选变量自动初始化为 nil
var stark: Adult?
stark = Adult(name: "斯塔克")
stark!.child = Child(name: "兰博", guardian: stark!)
stark = nil

/*
Adult 斯塔克 被销毁了!
Child 兰博 被销毁了!

Child实例中保存的是Adult实例的无主引用,所以当斯塔克被置nil之后,就再没有强引用指向Adult实例,所以Adult类的实例被 ARC 自动回收,同时Adult实例到Child实例的强引用也潇洒了,由于Child实例再也没有指向它的强引用,所以兰博也被销毁了.
*/
}

5：解环妙法捕获列表 其实也就是类实例和闭包之间的强引用环的处理.

强引用环不是只存在于两个引用类型之间吗?那么怎么又和闭包有关系呢?因为闭包也是引用类型,所以当你把一个闭包赋值给一个类属性时, Swift会帮你创建一个该类实例到闭包的强引用,又由于闭包能够捕获上下文中的变量,所以当你在该闭包内部调用该类实例的属性或者类方法时,闭包将会捕获该类实例的属性self,从而导致该闭包到该类实例的强引用也被创建,最终造成了类实例的闭包之间的强引用环.

//下面看一个天气预报的例子
class WeatherReport{

let location: String
let weather: String
var temperature: Int? //定义为可选,并不是所有人都关系温度.

//因为该计算属性使用到闭包,并且闭包中使用到了self,所以必然是惰性属性.
lazy var reports:() -> String = { //使用闭包赋值给reports属性,该属性类型为() -> String(可以理解为匿名函数也就是闭包).

if self.temperature != nil{

return "\(self.location)的天气预报是:\(self.weather),气温是:\(self.temperature)"
}else{

return "\(self.location)的天气预报是:\(self.weather)"
}
}

init(location: String, weather: String){

self.location = location
self.weather = weather
}

//如果该实例可以被 ARC 回收,则必然调用,否则说明该实例依然存在.
deinit{

print("\(location)的天气预报实例被销毁了!")
}
}
func testFive(){

var weatherReport:WeatherReport? = WeatherReport(location: "成都", weather: "多云")
print("\(weatherReport!.reports())")

//这句话告诉 ARC 该类可以被回收了.
weatherReport = nil

/*
打印结果:
成都的天气预报是:多云

分析:
1:当使用闭包去初始化一个类属性时,该属性前必须加lazy进行修饰,否则将不能够在闭包体内访问该类中的其他属性和方法,因为当闭包段代码被执行时,类是实例还没有完成初始化,self不起作用,另外及时加了 lazy修饰符,在闭包中不能隐式地访问self属性,必须显示的写出来.
2:在执行weatherReport = nil代码后,我们告诉 ARC 这个实例不用了,但是我们并没有获得相应的打印信息,因为有强引用环存在,那就是() -> String闭包任然作为强引用指向weatherReport的实例,所以 ARC 放弃了回收,从而造成内存泄露.
*/
}

//现在改成如下代码:
class WeatherReport{
let location: String
let weather: String
var temperature: Int? //定义为可选,并不是所有人都关系温度.

//因为该计算属性使用到闭包,并且闭包中使用到了self,所以必然是惰性属性.
//    lazy var reports:() -> String = { //使用闭包赋值给reports属性,该属性类型为() -> String(可以理解为匿名函数也就是闭包).
//        [unowned self] in
//        if self.temperature != nil{
//
//            return "\(self.location)的天气预报是:\(self.weather),气温是:\(self.temperature)"
//        }else{
//
//            return "\(self.location)的天气预报是:\(self.weather)"
//        }
//    }

/*
注意:如果闭包体当前实例未来永远不会为nil,那么使用无主类型,否则使用弱引用捕获类型,像这里,最好使用弱引用类型,因为该实例不会一直存在,只是用完了就释放掉了.
*/
lazy var reports:() -> String = {
[weak self] in
if self!.temperature != nil{
return "\(self!.location)的天气预报是:\(self!.weather),气温是:\(self!.temperature)"
}else{
return "\(self!.location)的天气预报是:\(self!.weather)"
}
}

init(location: String, weather: String){
self.location = location
self.weather = weather
}

//如果该实例可以被 ARC 回收,则必然调用,否则说明该实例依然存在.
deinit{
print("\(location)的天气预报实例被销毁了!")
}
}

打印如下:
成都的天气预报是:多云
成都的天气预报实例被销毁了!

/*
当我们在闭包体内添加[unowned self] in之后,可以看到打印如下:

成都的天气预报是:多云
成都的天气预报实例被销毁了!

调用了类的deinit方法,[unowned self]该语句就是捕获列表,其主要用途就是打破强引用关系,直接告诉Swift说这个闭包是普通的闭包,闭包中的self是对实例的无主引用,不会通过 ARC 保存这个实例.

注意捕获列表的几种格式:
普通的闭包前没有捕获列表都是强引用关系.
lazy var comeClosure(参数列表) -> 返回类型{

//闭包题
}

标准的闭包体加捕获列表
lazy var someClosureWithCaptureList(参数列表) -> 返回类型{

[捕获列表类型  捕获对象](参数) -> 返回类型 in
//闭包体
}

注意:

捕获列表类型  可以是weak,也可以是 unowned
捕获对象      代表具体的类实例,如 self或者otherInstance,如果有多个实例需要慎重引用类型,中间使用逗号隔开如:[unowned self,weak otherInstance].

如果闭包本身没有参数列表,简化如下:
lazy var someClosureWithCaptureList(参数列表) -> 返回类型{

[捕获列表类型  捕获对象] in
//闭包体

}
*/