Swift中如何解决循环引用问题？

为什么80%的码农都做不了架构师？>>>   

　

和OC一样,swift开发中也是使用自动引用计数ARC(Auto Reference Counteting)来自动管理内存的,所以我们不需要过多考虑内存管理.当某个类实例不需要用到的时候,ARC会自动释放其占用的内存.

　　ARC仅仅能对类的实例做内存管理,也就是只能针对引用类型.结构体和枚举都是值类型,不能通过引用的方式来传递和存储,所以ARC也就不能对它们进行内存管理.

　　什么情况下会导致循环引用

　　在swift中,每创建一个实例,ARC都会为其分配一块内存空间,而在不使用的时候,ARC会释放和收回那个实例所占的内存空间,该实例的属性和方法也就不能够被访问,如果要访问就会导致程序崩溃.

　　怎么确定实例不被使用了?ARC会自动追踪实例被多少常量和变量引用.每追踪到一个,自动引用计数会加一,减少一个引用自动引用计数会减一,如果当自动引用计数变为0的时候,ARC就会收回内存,销毁实例.

　　下面是一个自动引用计数的实例:

　　class Person {

　　let name: String

　　init(name: String) {

　　self.name = name

　　print("\(name)正在被初始化")

　　}

　　deinit {

　　print("\(name)即将被销毁") // person3 = nil时打印

　　}

　　}var person1: Person? // 可选类型的变量,方便置空var person2: Person?var person3: Person?

　　person1 = Person(name: "Dariel") //创建Person实例并与person1建立了强引用

　　person2 = person1 // 只要有一个强引用在,实例就能不被销毁

　　person3 = person1 // 目前该实例共有三个强引用

　　person1 = nil

　　person2 = nil // 因为还有一个强引用,实例不会被销毁

　　person3 = nil // 最后一个强引用被断开,ARC会销毁该实例

　　上面的例子中创建的 Person 实例最后引用计数变为了0被销毁了,但现实世界并不会一直都这么美好, ARC这种机制也有自己的局限性,请看下面的例子:

　　class People {

　　let name: String

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

　　var apartment: Apartment? // 人住的公寓属性deinit {

　　print("People被销毁")

　　}

　　}

　　class Apartment {

　　let unit: String

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

　　var tenant: People? // 公寓中的人的属性

　　deinit {

　　print("Apartment被销毁")

　　}

　　}

　　var people1: People? = People(name: "Dariel") // 定义两个实例变量var apartment1: Apartment? = Apartment(unit: "4A")

　　people1!.apartment = apartment1 // 两者相互引用

　　apartment1?.tenant = people1 // 而且彼此都是强引用

　　people1 = nil

　　apartment1 = nil // 两个引用都置为nil了,但实例并没有销毁

　　这一次直接创建了两个实例, People 中有一个 Apartment 的属性, Apartment 中又有一个 People 属性,当我们创建了两个实例后分别给实例中的这两个属性赋完值,又将两个可选变量赋值为nil,并没有看到两个实例被销毁的打印信息( deinit 函数会在实例被销毁的时候打印).

　　也就是说ARC并没有销毁两个对象.那么问题在哪里?

　　当两个可选变量被赋值为nil时,ARC并没有觉得这两个实例已经不在使用了.因为两个实例的相互赋值时使得各自的引用计数+1,这也就是发生循环引用了.

　　怎么解决循环引用

　　1. 如果产生循环引用的两个属性都允许为nil,这种情况适合用弱引用来解决

　　随便哪一个可选类型的属性前面都可以加 weak ,但记住只要加一个就行了.

　　话不多说上代码:

　　class OtherPeople {

　　let name: String

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

　　var apartment: OtherApartment? // 人住的公寓属性

　　deinit { print("\(name)被销毁") }

　　}

　　class OtherApartment {

　　let unit: String

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

　　weak var tenant: OtherPeople? // 加一个weak关键字,表示该变量为弱引用

　　deinit { print("\(unit)被销毁") }

　　}

　　var otherPeople1: OtherPeople? = OtherPeople(name: "Dariel") // 定义两个实例变量var otherApartment1: OtherApartment? = OtherApartment(unit: "4A")

　　otherPeople1!.apartment = otherApartment1 // 两者相互引用

　　otherApartment1?.tenant = otherPeople1 // 但tenant是弱引用

　　otherPeople1 = nil

　　otherApartment1 = nil // 实例被销毁,deinit中都会打印销毁的信息

　　在 OtherPeople 和 OtherApartment 两个类中,相互引用的两个属性都为可选类型,那么可以在一个属性的前面添加 weak 关键字,使该变量变为弱引用.

　　对的,没错,这个weak还是以前OC里面的那个weak.

　　2. 如果产生循环引用的两个属性一个允许为nil,另一个不允许为nil,这种情况适合用无主引用来解决

　　只能在不能为nil的那个属性前面加 unowned 关键字,就是说 unowned 设置以后即使它原来引用的内容已经被释放了，它仍然会保持对被已经释放了的对象的一个 "无效的" 引用，它不能是 Optional 值，也不会被指向 nil。如果尝试去调用这个引用的方法或者访问成员属性的话，程序就会崩溃.

　　无主引用的例子:

　　class Dog {

　　let name: String

　　var food: Food?

　　init(name: String) {

　　self.name = name

　　}

　　deinit { print("\(name)被销毁") }

　　}class Food {

　　let number: Int

　　unowned var owner: Dog // owner是一个无主引用

　　init(number: Int, owner: Dog) {

　　self.number = number

　　self.owner = owner

　　}

　　deinit { print("食物被销毁") }

　　}

　　var dog1: Dog? = Dog(name: "Kate")

　　dog1?.food = Food(number: 6, owner: dog1!) // dog强引用food,而food对dog是无主引用

　　dog1 = nil // 这样就可以同时销毁两个实例了

　　Dog 的 food 属性可以为空,而 Food 的 owner 属性不能为空,我们把 owner 设为无主引用.

　　3. 如果产生循环引用的两个属性都必须有值,不能为nil,这种情况适合一个类使用无主属性,另一个类使用隐式解析可选类型

　　隐式解析可选类型: 类似可选类型,默认值可以设置为nil

　　两个属性一个在类型后面加 ! 设置为隐式解析可选类型,另一个在属性前面加unowned 关键字,设置为无主属性.

　　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实例被销毁") }

　　}

　　class City {

　　let name: String

　　unowned let country: Country

　　init(name: String, country: Country) {

　　self.name = name

　　self.country = country

　　}

　　deinit { print("City实例被销毁") }

　　}

　　// 这样一条语句就能够创建两个实例var country: Country? = Country(name: "China", capitalName: "HangZhou")print(country!.name) // Chinaprint(country!.capitalCity.name) // HangZhou

　　country = nil // 同时销毁两个实例

　　Country 的 City 属性后加!为隐式解析可选属性,类似可选类型,capitalCity属性的默认值为nil,一旦在 Country 的构造函数中给 name 属性赋完值后, Country 的整个初始化过程就完成了,就能将 self 作为参数传递给 City 的构造函数了.

　　总而言之,就是一条语句创建两个实例,还不产生循环引用.

　　闭包也是引用类型,怎么解决闭包的循环强引用

　　闭包中对任何其他元素的引用都是会被闭包自动持有的。如果我们在闭包中写了self 这样的东西的话，那我们其实也就在闭包内持有了当前的对象。这里就出现了一个在实际开发中比较隐蔽的陷阱：如果当前的实例直接或者间接地对这个闭包又有引用的话，就形成了一个 self -> 闭包 -> self 的循环引用

　　怎样避免这种情况呢?

　　可以在闭包开始的时候添加一个标注，来表示这个闭包内的某些要素应该以何种特定的方式来使用

　　看例子:

　　class Element {

　　let name: String

　　let text: String?

　　lazy var group:() -> String = { // 相当于一个没有参数返回string的函数

　　[unowned self] in // 定义捕获列表,将self变为无主引用

　　if let text = self.text { // 解包

　　return "\(self.name), \(text)"

　　}else {

　　return "\(self.name)"

　　}

　　}

　　init(name: String, text: String? = nil) {

　　self.name = name

　　self.text = text

　　}

　　deinit { print("\(name)被销毁") }

　　}

　　var element1: Element? = Element(name: "Alex", text: "Hello")print(element1!.group()) // Alex, Hello,闭包与实例相互引用

　　element1 = nil // self为无主引用,实例能被销毁

　　在闭包中定义一个捕获列表 [unowned self] ,将self变为无主引用.这样就能够在避免产生循环强引用了.

　　小结

　　解决循环引用的三种方法,这三种方法的产生主要还是swift中要考虑属性为空的情况.

　　· 如果产生循环引用的两个属性都允许为nil,这种情况适合用弱引用来解决.

　　· 如果产生循环引用的两个属性一个允许为nil,另一个不允许为nil,这种情况适合用无主引用来解决.

　　· 如果产生循环引用的两个属性都必须有值,不能为nil,这种情况适合一个类使用无主属性,另一个类使用隐式解析可选类型 .

 

文章来源：简书

转载于:https://my.oschina.net/sdeqq/blog/781843