swift详解之九---------------自动引用计数、循环引用

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

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

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 //张三 实例被销毁啦！！！
//这时候所有的强引用都释放 ， 则释放这个实例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28

这里注释写的很清楚，只有当所有的强引用释放掉，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 被销毁啦 ")
}
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26

这里在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 

    1
    2
    3
    4
    5
    6
    7

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

解决循环强引用问题

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 被销毁啦
//哈哈 两个都可以被销毁啦

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33

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

前面两种解决循环引用的场景，第一种是两个都允许为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 被销毁啦")
}
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27


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 被销毁啦

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21

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

解决办法：
定义捕获列表：捕获列表中的每一项都由一对元素组成，一个是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 被销毁了

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22

这时会就被顺利销毁了

看下语法：

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

    1
    2
    3
    4
    5
    6
    7
    8
    9

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

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

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

posted on 2015-09-05 21:37 motoyang 阅读(369) 评论(0) 编辑收藏举报

swift详解之九---------------自动引用计数、循环引用

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

1、 自动引用计数原理

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

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

1、自动引用计数原理