14-Swift自动引用计数(循环引用的解决)

swift使用自动引用计数(ARC)机制来跟踪和管理应用程序的内存。一般情况下，swift内存管理机制会一直起作用，即开发者无需考虑内存管理。ARC会在类的实例不再使用时，即没有引用的时候，自动释放其所占用的内存。
 但是要注意，引用计数仅仅应用在类的实例，因为结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递的。

一、自动引用计数的工作机制

---

当在创建一个类的实例时，ARC会分配一个内存用于存储实例的信息。内存中会包含实例的类型信息，以及这个实例中所有相关属性的值。
 当实例不再被使用时，ARC会释放该实例所占用的内存，并让释放的内存挪作他用。这即是确保了不再被使用的实例，不会一直占用内存空间。
 为了确保使用中的实例不会被销毁，ARC会跟踪和计算每个实例正在被多少属性、变量和常量所引用，只要是实例还有被引用，ARC就不会销毁该实例。

不论是将实例赋值给属性、常量还是变量，它们都会创建对此实例的强引用。强引用就是将实例牢牢的保持住，只要是有强引用，实例就不会被销毁!!!

二、自动引用计数实践

---

以下是展示自动引用计数的工作机制:

class Student {
    let name:String
    init(name:String) { // 构造器
        self.name = name;
        print("名字的初始值为:\(name)");
    }

    deinit {    // 析构器
        print("实例将会被释放 --- \(name)");
    }
}

// 定义三个学生变量，类型是Student?，注意是可选类型
var student1:Student?;
var student2:Student?;
var student3:Student?;
// 实例化，注意这里就是一个强引用
// // 此时Student实例强引用计数为1
student1 = Student(name: "张三");
print("学生姓名: \(student1!.name)");
// 赋值操作
student2 = student1; // 此时Student实例强引用计数为2
student3 = student1; // 此时Student实例强引用计数为3
// 通过设置变量为`nil`，即是断开强引用
student1 = nil; // 此时Student实例强引用计数为2
student2 = nil; // 此时Student实例强引用计数为1

// 注意看打印效果，此时Student实例是没有被使用的，因为`deinit`析构器中代码还没被调用

// 当student3设置为`nil`时，此时Student实例强引用计数为0
student3 = nil;
// 当没有强引用的时候，才会被销毁

输出结果:
名字的初始值为:张三
学生姓名: 张三
实例将会被释放 --- 张三

三、类实例之间引起的循环引用

---

如果两个类实例相互持有对方的强引用，这即是循环引用。解决办法就是通过定义类之间关系为弱引用或无主引用，以代替强引用(下面会有实际解决实例，这里先了解循环引用是怎么产生的)。

/** 
 Student学生类: 具体某个学生，哪个班级
 Grade班级类: 具体班级，班级里的学生有谁
 */
class Student {
    // 学生名字
    let name:String
    // 构造器
    init(name:String) {
        self.name = name
    }

    // 哪个班级
    var grade:Grade?

    // 析构器
    deinit {
        print("实例将会被释放 --- \(name)");
    }
}

class Grade {
    // 哪个班级
    let gradeName:String
    //构造器
    init(gradeName:String) {
        self.gradeName = gradeName
    }

    // 班级中的学生
    var student:Student?

    // 析构器
    deinit {
        print("实例将会被释放 --- \(gradeName)");
    }
}

// 学生: 张三
var student:Student? = Student(name: "张三")
// 班级: 一年一班
var grade:Grade? = Grade(gradeName: "一年一班")

// 张三是在一年一班
student!.grade = grade
// 一年一班中的学生
grade!.student = student

// 设置为`nil`，因为它们都是可选类型的
student = nil
grade = nil

// 但是Student和Grade的析构器都没调用，说明它们的实例是没有被释放

开始，实例化操作，那么此时对应类的实例都只有一个强引用所指向(图中实线就表示强引用):

之后，是赋值操作student!.grade = grade和grade!.student = student，此时:

最后，设置student = nil和grade = nil，此时:

从上可以看到，Student和Grade的实例都是有强引用，即实例不会被释放掉，那么这也就会造成内存的泄漏。

四、解决实例之间的循环引用

---

swift提供了两种办法用来解决循环引用的问题:弱引用和无主引用。
 弱引用和无主引用允许循环引用中的一个实例引用和另一个实例而不是保持强引用，这也就不会产生循环引用问题。
 对于生命周期中会为nil的实例使用弱引用。但对于初始化值后不会再被赋值为nil的实例，则使用无主引用。

• 弱引用，是不会阻止ARC销毁被引用的实例，或者说弱引用是不计数是不会加一操作的。当声明属性或变量时，在前面加上weak关键字表明一个弱引用。

// 注: 与上面代码一样，只是在定义student属性时，进行了弱化操作
class Grade {
    // 哪个班级
    let gradeName:String
    // 构造器
    init(gradeName:String) {
        self.gradeName = gradeName
    }

    // 班级中的学生
    // var student:Student?
    // 弱引用操作，解决实例之间的循环引用
    weak var student:Student?

    // 析构器
    deinit {
        print("实例将会被释放 --- \(gradeName)");
    }
}

当设置student = nil和grade = nil的时候(注意图中标注的先后顺序。另外只要实例没有强引用，那么会被释放):

注意1: 弱引用必须被声明为变量，表明其值能在运行时被修改！！！另外，弱引用可以没有值，所以也必须将弱引用声明为可选类型。而swift中也是推荐使用可选类型来描述可能没有值的类型。
注意2: 在使用垃圾收集的系统里，弱指针有时候来实现简单的缓冲机制，因为没有强引用的对象只会在内存压力触发垃圾收集时才会被销毁。但ARC中，一旦值的最后一个强引用被删除，就会被立即销毁，这导致弱引用并不适合上面的用途。

• 无主引用，与弱引用类似，无主引用也不会牢牢保持住引用的实例。但与弱引用不同的是，无主引用永远是有值的！！！因此无主引用总是被定义为非可选类型。而在声明属性或变量时，在前面加上unowned关键字来表示是一个无主引用。由于无主引用是非可选类型，你不需要再使用它的时候将它展开，无主引用总是可以被直接访问。但ARC无法再实例被实例销毁后将无主引用设置为nil，因为非可选类型的变量不允许被赋值为nil。

注意: 如果你试图在实例被销毁后，访问该实例的无主引用，会导致程序崩溃。使用无主引用，必须要确保引用始终指向一个未销毁的实例。

/** 无主引用
 例如银行顾客Customer和信用卡CreditCard；
 一个人可以有或没有信用卡，但一张信用卡必须与一个客户关联；
 */
// 银行顾客
class Customer {
    // 用户名
    let name:String
    // 用户对应的信用卡，可选类型表示可以有卡，也可以没有卡
    var card:CreditCard?

    init(name:String) {
        self.name = name
    }
    deinit {
        print("银行顾客-实例被销毁 --- \(self.name)")
    }
}

// 信用卡
class CreditCard {
    // 卡号
    let number:UInt64
    // 无主引用，避免循环引用(非可选类型，信用卡实例必须与一个客户关联)
    unowned let customer:Customer

    init(number:UInt64, customer:Customer) {
        self.number = number
        self.customer = customer
    }
    deinit {
        print("信用卡-实例被销毁 --- \(self.number)")
    }
}

// 银行客户，张三(可选类型，是可以设置为`nil`)
var zhangsan:Customer? = Customer(name:"张三");
// 张三的信用卡【注意，初始化的时候将卡号与张三实例传进去】
zhangsan!.card = CreditCard(number: 1234_5678_9101_1121,customer: zhangsan!)

// 设置为空，即断开对Customer实例的引用，检查是否会正常释放
zhangsan = nil

输出结果:
银行顾客-实例被销毁 --- 张三
信用卡-实例被销毁 --- 1234567891011121

银行客户与信用卡绑定后，它们之间的关系:

之后，设置zhangsan = nil，此时Customer实例张三没有强引用，那么会被释放。而Customer实例张三释放以后，CreditCard实例也就没有强引用，也会被释放，如图所示:

• 无主引用以及隐式解析可选属性。Student和Grade示例中，两个属性的值都允许为nil，并存在循环引用，这种场景最适合弱引用解决；Customer和CreditCard示例中，一个属性允许设置为nil，而另外一个属性是不允许为nil，并存在循环引用，这种常见最适合无主引用解决；而当两个属性都必须有值，并初始化完成后将都不会为nil，这种场景需要一个类使用无主属性，另外一个类使用隐式解析可选属性来解决:

/** 
 无主引用以及隐式解析可选属性
 Country国家和City城市；
 每个国家必须有首都，而每个城市必须属于一个国家；
 */
// 国家类
class Country {
    // 国家名
    let name:String
    // 首都城市，是隐式解析可选类型(默认是为空，这是不展开都可使用)
    var capitalCity:City!
    init(name:String, capitalName:String) {
        // 指定国家名
        self.name = name
        // 指定首都城市，传入城市名以及国家实例
        self.capitalCity = City(name:capitalName, country: self)
    }  
    deinit {
        print("Country实例被释放 --- \(name)")
    }
}
// 城市类
class City {
    // 城市名
    let name:String
    // 所属首都，是无主类型
    unowned let country:Country

    init(name:String, country:Country) {
        self.name = name
        self.country = country
    }
    deinit {
        print("City实例被释放 --- \(name)")
    }
}
var country = Country(name: "中国", capitalName: "北京")
print("\(country.name) - \(country.capitalCity.name)")
输出结果:
中国 - 北京

五、闭包引起的循环引用

---

在闭包赋值给类实例的某个属性时也会有强引用。闭包体中可能访问实例的某个属性，例如self.someProperty，或者闭包调用了实例中的某个方法，例如self.someMethod，这都会导致闭包"捕获"self,从而产生了循环引用:

/** 
 闭包的循环引用
 */
class Person {
    // 名字
    let name:String

    // 懒加载，自我介绍
    lazy var speakStr:Void -> String = {
        // 闭包中
        return "大家好，我叫\(self.name)"
    }

    init(name:String) {
        self.name = name
    }
    deinit {
        print("Person实例释放 --- \(name)");
    }
}

// 初始化
var zhangsan:Person? = Person(name: "张三")
// 调用
print(zhangsan!.speakStr())

// 断开对Person实例的引用，但此时Person实例不会被销毁
zhangsan = nil

六、解决闭包引起的循环引用

---

对于闭包所引起的循环引用，在swift中提供了一种解决办法，即是闭包捕获列表。在定义闭包同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环引用。捕获列表定义了闭包体内捕获一个或多个引用类型的规则，这与解决两个类之间的循环引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。
 在闭包中需要注意的是，只要在闭包中要使用本对象中的属性或方法，就必须要使用self.someProperty或self.someMethod()，而不能使用someProperty或someMethod()。
 定义捕获列表，在捕获列表中的每一项都由需要加上weak或unowned关键字。
 在闭包和捕获的实例总是相互引用时并且是同时销毁时，可以将闭包内的捕获定义为无主引用。
 而在被捕获的引用可能会为nil时，将闭包内的捕获定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为nil。
 如果是被捕获的引用绝对不会变为nil，应该用无主引用，而不是引用。

// 闭包有参数列表和返回类型的定义，把捕获列表放在前面
lazy var someClosure:(Int, String) -> String = {
  [unowned self, weak delegate = self.delegate!] (index:Int ,stringToProcess:String) -> String in
    // 闭包中对应操作
}

// 闭包没有指定参数列表或返回类型，即会通过上下文推断，那么可以把捕获列表和关键字`in`放在闭包最开始地方
lazy var someClosure:Void -> String = {
  [unowned self, weak delegate = self.delegate!] in 
    // 闭包中对应操作
}

class Person {
    // 名字
    let name:String

    // 懒加载，自我介绍
    lazy var speakStr:Void -> String = {
        // 解决循环引用，即表示"用无主引用而不是强引用来捕获self"
        [unowned self] in
        // 闭包中
        return "大家好，我叫\(self.name)"
    }

    init(name:String) {
        self.name = name
    }
    deinit {
        print("Person实例释放 --- \(name)");
    }
}

// 初始化
var zhangsan:Person? = Person(name: "张三")
// 调用
print(zhangsan!.speakStr())

// 断开对Person实例的引用，此时Person实例就会被销毁
zhangsan = nil
输出结果:
大家好，我叫张三
Person实例释放 --- 张三

注：xcode7.3环境

作者：西门奄
链接：https://www.jianshu.com/u/77035eb804c3
來源：
著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。