(二十四)[Swift]循环引用

1.什么是循环引用

两个对象通过属性互相强引用对方，导致无法正常释放

情境代码

class City{
    var country : Country?
    deinit{
        print("city is deinit")
    }
}
class Country {
    var capital : City?
    deinit{
        print("country is deinit")
    }
}

不会循环引用

var city:City? = City()
var country:Country? = Country()
city!.country = country!
city = nil
country = nil
//city country此时释放会正常打印
//city is deinit
//country is deinit

会导致循环引用

var city2:City? = City()
var country2:Country? = Country()

city2!.country = country2!
country2!.capital=city2!
city2 = nil
country2 = nil
//city country此时设为nil,没有任何打印，说明并不会正常释放

两个强指针指向对方导致互相无法释放

2.在optional类型的属性中加上weak关键字

weak关键词不会使引用计数+1，同时如果所指向对象被释放，则自动设为nil

class City2{
   weak var country : Country2?
    deinit{
        print("city2 is deinit")
    }
}
class Country2 {
    var capital : City2?
    deinit{
        print("country2 is deinit")
    }
}

var city2:City2? = City2()
var country2:Country2? = Country2()
country2?.capital=city2!
city2?.country=country2

city2?.country == nil  //false
country2 = nil //打印 country is deinit
city2?.country == nil  //true
city2 = nil   //打印 city2 is deinit

有一方为weak类型属性的示意图

3.在非optional类型的属性中加上unown关键字

unown关键字只是不会使引用计数+1，所指向的对象被释放后，此属性不能再被访问，否则会报错

class City3{
    var country : Country3?
    deinit{
        print("city3 is deinit")
    }
}
class Country3 {
    unowned var capital : City3
    init(capital:City3){
        self.capital = capital;
    }
    deinit{
        print("country3 is deinit")
    }
}

var city3:City3? = City3()
var country3:Country3? = Country3(capital:city3!)

city3?.country=country3

  //打印 city2 is deinit
country3?.capital == nil  //false
city3 = nil //打印 city3 is deinit
//country3?.capital == nil  //报错
country3 = nil //打印 country3 is deinit

有一方为unowned类型属性的示意图

所以应该根据实际情况来决定是使用unowned关键字还是weak关键字

4.closure中的循环引用

class HTMLElement{
    var text:String
    init(text:String){
        self.text=text
    }
    lazy var asHTML : Void -> String = { 
        return "<text>\(self.text)</text>"
    }
    deinit{
        print("HTMLElement 被 释放了")
    }
}

看起来并没有什么问题,编译器也没有报错
但是

var e :HTMLElement?  = HTMLElement(text:"haha")
e?.asHTML()
e = nil //并没有任何打印,说明发生了循环引用

为什么会发生循环引用?

因为closure实际上也是一个对象，并且会捕获其所用到的变量。并默认使用一个强类型的指针，指向其用到的变量。这里发生的情况，如图

HTMLElement与Closure循环引用示意图

那么如何将其中的一个强类型指针改变成weak或者unowned呢?改变asHTML属性的类型为weak或者unowned吗？

显然不行，weak 和 unowned 只适用于class和protocol类型的属性

那只有修改closure中self的指针类型了
这样,在closure中加上[unowned self]的说明

class HTMLElement{
    var text:String
    init(text:String){
        self.text=text
    }
    lazy var asHTML : Void -> String = { [unowned self] in
        return "<text>\(self.text)</text>"
    }
    deinit{
        print("HTMLElement 被 释放了")
    }
}

如果是多个说明的话用逗号隔开比如

[unowned self,weak other]

这个说明应该放在参数列表的前面

  lazy var asHTML : Void -> String = { [unowned self] () -> String in
        return "<text>\(self.text)</text>"
    }

加上说明再来测试一下

var e :HTMLElement? = HTMLElement(text:"haha")
e?.asHTML()
e = nil //打印HTMLElement 被 释放了 

说明正常释放了